Files
42
Total Lines
26812
Coverage
22.0%
284 / 1278 lines
Actions
50.0%
lib/forge-std/src/Base.sol
Lines covered: 1 / 2 (50.0%)
| 1 | // SPDX-License-Identifier: MIT |
| 2 | pragma solidity >=0.6.2 <0.9.0; |
| 3 | |
| 4 | import {StdStorage} from "./StdStorage.sol"; |
| 5 | import {Vm, VmSafe} from "./Vm.sol"; |
| 6 | |
| 7 | abstract contract CommonBase { |
| 8 | /// @dev Cheat code address. |
| 9 | /// Calculated as `address(uint160(uint256(keccak256("hevm cheat code"))))`. |
| 10 | address internal constant VM_ADDRESS = 0x7109709ECfa91a80626fF3989D68f67F5b1DD12D; |
| 11 | |
| 12 | /// @dev console.sol and console2.sol work by executing a staticcall to this address. |
| 13 | /// Calculated as `address(uint160(uint88(bytes11("console.log"))))`. |
| 14 | address internal constant CONSOLE = 0x000000000000000000636F6e736F6c652e6c6f67; |
| 15 | |
| 16 | /// @dev Used when deploying with create2. |
| 17 | /// Taken from https://github.com/Arachnid/deterministic-deployment-proxy. |
| 18 | address internal constant CREATE2_FACTORY = 0x4e59b44847b379578588920cA78FbF26c0B4956C; |
| 19 | |
| 20 | /// @dev The default address for tx.origin and msg.sender. |
| 21 | /// Calculated as `address(uint160(uint256(keccak256("foundry default caller"))))`. |
| 22 | address internal constant DEFAULT_SENDER = 0x1804c8AB1F12E6bbf3894d4083f33e07309d1f38; |
| 23 | |
| 24 | /// @dev The address of the first contract `CREATE`d by a running test contract. |
| 25 | /// When running tests, each test contract is `CREATE`d by `DEFAULT_SENDER` with nonce 1. |
| 26 | /// Calculated as `VM.computeCreateAddress(VM.computeCreateAddress(DEFAULT_SENDER, 1), 1)`. |
| 27 | address internal constant DEFAULT_TEST_CONTRACT = 0x5615dEB798BB3E4dFa0139dFa1b3D433Cc23b72f; |
| 28 | |
| 29 | /// @dev Deterministic deployment address of the Multicall3 contract. |
| 30 | /// Taken from https://www.multicall3.com. |
| 31 | address internal constant MULTICALL3_ADDRESS = 0xcA11bde05977b3631167028862bE2a173976CA11; |
| 32 | |
| 33 | /// @dev The order of the secp256k1 curve. |
| 34 | uint256 internal constant SECP256K1_ORDER = |
| 35 | 115792089237316195423570985008687907852837564279074904382605163141518161494337; |
| 36 | |
| 37 | uint256 internal constant UINT256_MAX = |
| 38 | 115792089237316195423570985008687907853269984665640564039457584007913129639935; |
| 39 | |
| 40 | Vm internal constant vm = Vm(VM_ADDRESS); |
| 41 | StdStorage internal stdstore; |
| 42 | } |
| 43 | |
| 44 | abstract contract TestBase is CommonBase {} |
| 45 | |
| 46 | abstract contract ScriptBase is CommonBase { |
| 47 | VmSafe internal constant vmSafe = VmSafe(VM_ADDRESS); |
| 48 | } |
| 49 |
88.0%
lib/forge-std/src/StdAssertions.sol
Lines covered: 8 / 9 (88.0%)
| 1 | // SPDX-License-Identifier: MIT |
| 2 | pragma solidity >=0.6.2 <0.9.0; |
| 3 | pragma experimental ABIEncoderV2; |
| 4 | |
| 5 | import {Vm} from "./Vm.sol"; |
| 6 | |
| 7 | abstract contract StdAssertions { |
| 8 | Vm private constant vm = Vm(address(uint160(uint256(keccak256("hevm cheat code"))))); |
| 9 | |
| 10 | event log(string); |
| 11 | event logs(bytes); |
| 12 | |
| 13 | event log_address(address); |
| 14 | event log_bytes32(bytes32); |
| 15 | event log_int(int256); |
| 16 | event log_uint(uint256); |
| 17 | event log_bytes(bytes); |
| 18 | event log_string(string); |
| 19 | |
| 20 | event log_named_address(string key, address val); |
| 21 | event log_named_bytes32(string key, bytes32 val); |
| 22 | event log_named_decimal_int(string key, int256 val, uint256 decimals); |
| 23 | event log_named_decimal_uint(string key, uint256 val, uint256 decimals); |
| 24 | event log_named_int(string key, int256 val); |
| 25 | event log_named_uint(string key, uint256 val); |
| 26 | event log_named_bytes(string key, bytes val); |
| 27 | event log_named_string(string key, string val); |
| 28 | |
| 29 | event log_array(uint256[] val); |
| 30 | event log_array(int256[] val); |
| 31 | event log_array(address[] val); |
| 32 | event log_named_array(string key, uint256[] val); |
| 33 | event log_named_array(string key, int256[] val); |
| 34 | event log_named_array(string key, address[] val); |
| 35 | |
| 36 | bytes32 private constant FAILED_SLOT = bytes32("failed"); |
| 37 | |
| 38 | bool private _failed; |
| 39 | |
| 40 | function failed() public view returns (bool) { |
| 41 | if (_failed) { |
| 42 | return true; |
| 43 | } else { |
| 44 | return vm.load(address(vm), FAILED_SLOT) != bytes32(0); |
| 45 | } |
| 46 | } |
| 47 | |
| 48 | function fail() internal virtual { |
| 49 | vm.store(address(vm), FAILED_SLOT, bytes32(uint256(1))); |
| 50 | _failed = true; |
| 51 | } |
| 52 | |
| 53 | function fail(string memory message) internal virtual { |
| 54 | fail(); |
| 55 | vm.assertTrue(false, message); |
| 56 | } |
| 57 | |
| 58 | function assertTrue(bool data) internal pure virtual { |
| 59 | if (!data) { |
| 60 | vm.assertTrue(data); |
| 61 | } |
| 62 | } |
| 63 | |
| 64 | function assertTrue(bool data, string memory err) internal pure virtual { |
| 65 | if (!data) { |
| 66 | vm.assertTrue(data, err); |
| 67 | } |
| 68 | } |
| 69 | |
| 70 | function assertFalse(bool data) internal pure virtual { |
| 71 | if (data) { |
| 72 | vm.assertFalse(data); |
| 73 | } |
| 74 | } |
| 75 | |
| 76 | function assertFalse(bool data, string memory err) internal pure virtual { |
| 77 | if (data) { |
| 78 | vm.assertFalse(data, err); |
| 79 | } |
| 80 | } |
| 81 | |
| 82 | function assertEq(bool left, bool right) internal pure virtual { |
| 83 | if (left != right) { |
| 84 | vm.assertEq(left, right); |
| 85 | } |
| 86 | } |
| 87 | |
| 88 | function assertEq(bool left, bool right, string memory err) internal pure virtual { |
| 89 | if (left != right) { |
| 90 | vm.assertEq(left, right, err); |
| 91 | } |
| 92 | } |
| 93 | |
| 94 | function assertEq(uint256 left, uint256 right) internal pure virtual { |
| 95 | if (left != right) { |
| 96 | vm.assertEq(left, right); |
| 97 | } |
| 98 | } |
| 99 | |
| 100 | function assertEq(uint256 left, uint256 right, string memory err) internal pure virtual { |
| 101 | if (left != right) { |
| 102 | vm.assertEq(left, right, err); |
| 103 | } |
| 104 | } |
| 105 | |
| 106 | function assertEqDecimal(uint256 left, uint256 right, uint256 decimals) internal pure virtual { |
| 107 | vm.assertEqDecimal(left, right, decimals); |
| 108 | } |
| 109 | |
| 110 | function assertEqDecimal(uint256 left, uint256 right, uint256 decimals, string memory err) internal pure virtual { |
| 111 | vm.assertEqDecimal(left, right, decimals, err); |
| 112 | } |
| 113 | |
| 114 | function assertEq(int256 left, int256 right) internal pure virtual { |
| 115 | if (left != right) { |
| 116 | vm.assertEq(left, right); |
| 117 | } |
| 118 | } |
| 119 | |
| 120 | function assertEq(int256 left, int256 right, string memory err) internal pure virtual { |
| 121 | if (left != right) { |
| 122 | vm.assertEq(left, right, err); |
| 123 | } |
| 124 | } |
| 125 | |
| 126 | function assertEqDecimal(int256 left, int256 right, uint256 decimals) internal pure virtual { |
| 127 | vm.assertEqDecimal(left, right, decimals); |
| 128 | } |
| 129 | |
| 130 | function assertEqDecimal(int256 left, int256 right, uint256 decimals, string memory err) internal pure virtual { |
| 131 | vm.assertEqDecimal(left, right, decimals, err); |
| 132 | } |
| 133 | |
| 134 | function assertEq(address left, address right) internal pure virtual { |
| 135 | if (left != right) { |
| 136 | vm.assertEq(left, right); |
| 137 | } |
| 138 | } |
| 139 | |
| 140 | function assertEq(address left, address right, string memory err) internal pure virtual { |
| 141 | if (left != right) { |
| 142 | vm.assertEq(left, right, err); |
| 143 | } |
| 144 | } |
| 145 | |
| 146 | function assertEq(bytes32 left, bytes32 right) internal pure virtual { |
| 147 | if (left != right) { |
| 148 | vm.assertEq(left, right); |
| 149 | } |
| 150 | } |
| 151 | |
| 152 | function assertEq(bytes32 left, bytes32 right, string memory err) internal pure virtual { |
| 153 | if (left != right) { |
| 154 | vm.assertEq(left, right, err); |
| 155 | } |
| 156 | } |
| 157 | |
| 158 | function assertEq32(bytes32 left, bytes32 right) internal pure virtual { |
| 159 | if (left != right) { |
| 160 | vm.assertEq(left, right); |
| 161 | } |
| 162 | } |
| 163 | |
| 164 | function assertEq32(bytes32 left, bytes32 right, string memory err) internal pure virtual { |
| 165 | if (left != right) { |
| 166 | vm.assertEq(left, right, err); |
| 167 | } |
| 168 | } |
| 169 | |
| 170 | function assertEq(string memory left, string memory right) internal pure virtual { |
| 171 | vm.assertEq(left, right); |
| 172 | } |
| 173 | |
| 174 | function assertEq(string memory left, string memory right, string memory err) internal pure virtual { |
| 175 | vm.assertEq(left, right, err); |
| 176 | } |
| 177 | |
| 178 | function assertEq(bytes memory left, bytes memory right) internal pure virtual { |
| 179 | vm.assertEq(left, right); |
| 180 | } |
| 181 | |
| 182 | function assertEq(bytes memory left, bytes memory right, string memory err) internal pure virtual { |
| 183 | vm.assertEq(left, right, err); |
| 184 | } |
| 185 | |
| 186 | function assertEq(bool[] memory left, bool[] memory right) internal pure virtual { |
| 187 | vm.assertEq(left, right); |
| 188 | } |
| 189 | |
| 190 | function assertEq(bool[] memory left, bool[] memory right, string memory err) internal pure virtual { |
| 191 | vm.assertEq(left, right, err); |
| 192 | } |
| 193 | |
| 194 | function assertEq(uint256[] memory left, uint256[] memory right) internal pure virtual { |
| 195 | vm.assertEq(left, right); |
| 196 | } |
| 197 | |
| 198 | function assertEq(uint256[] memory left, uint256[] memory right, string memory err) internal pure virtual { |
| 199 | vm.assertEq(left, right, err); |
| 200 | } |
| 201 | |
| 202 | function assertEq(int256[] memory left, int256[] memory right) internal pure virtual { |
| 203 | vm.assertEq(left, right); |
| 204 | } |
| 205 | |
| 206 | function assertEq(int256[] memory left, int256[] memory right, string memory err) internal pure virtual { |
| 207 | vm.assertEq(left, right, err); |
| 208 | } |
| 209 | |
| 210 | function assertEq(address[] memory left, address[] memory right) internal pure virtual { |
| 211 | vm.assertEq(left, right); |
| 212 | } |
| 213 | |
| 214 | function assertEq(address[] memory left, address[] memory right, string memory err) internal pure virtual { |
| 215 | vm.assertEq(left, right, err); |
| 216 | } |
| 217 | |
| 218 | function assertEq(bytes32[] memory left, bytes32[] memory right) internal pure virtual { |
| 219 | vm.assertEq(left, right); |
| 220 | } |
| 221 | |
| 222 | function assertEq(bytes32[] memory left, bytes32[] memory right, string memory err) internal pure virtual { |
| 223 | vm.assertEq(left, right, err); |
| 224 | } |
| 225 | |
| 226 | function assertEq(string[] memory left, string[] memory right) internal pure virtual { |
| 227 | vm.assertEq(left, right); |
| 228 | } |
| 229 | |
| 230 | function assertEq(string[] memory left, string[] memory right, string memory err) internal pure virtual { |
| 231 | vm.assertEq(left, right, err); |
| 232 | } |
| 233 | |
| 234 | function assertEq(bytes[] memory left, bytes[] memory right) internal pure virtual { |
| 235 | vm.assertEq(left, right); |
| 236 | } |
| 237 | |
| 238 | function assertEq(bytes[] memory left, bytes[] memory right, string memory err) internal pure virtual { |
| 239 | vm.assertEq(left, right, err); |
| 240 | } |
| 241 | |
| 242 | // Legacy helper |
| 243 | function assertEqUint(uint256 left, uint256 right) internal pure virtual { |
| 244 | assertEq(left, right); |
| 245 | } |
| 246 | |
| 247 | function assertNotEq(bool left, bool right) internal pure virtual { |
| 248 | if (left == right) { |
| 249 | vm.assertNotEq(left, right); |
| 250 | } |
| 251 | } |
| 252 | |
| 253 | function assertNotEq(bool left, bool right, string memory err) internal pure virtual { |
| 254 | if (left == right) { |
| 255 | vm.assertNotEq(left, right, err); |
| 256 | } |
| 257 | } |
| 258 | |
| 259 | function assertNotEq(uint256 left, uint256 right) internal pure virtual { |
| 260 | if (left == right) { |
| 261 | vm.assertNotEq(left, right); |
| 262 | } |
| 263 | } |
| 264 | |
| 265 | function assertNotEq(uint256 left, uint256 right, string memory err) internal pure virtual { |
| 266 | if (left == right) { |
| 267 | vm.assertNotEq(left, right, err); |
| 268 | } |
| 269 | } |
| 270 | |
| 271 | function assertNotEqDecimal(uint256 left, uint256 right, uint256 decimals) internal pure virtual { |
| 272 | vm.assertNotEqDecimal(left, right, decimals); |
| 273 | } |
| 274 | |
| 275 | function assertNotEqDecimal(uint256 left, uint256 right, uint256 decimals, string memory err) |
| 276 | internal |
| 277 | pure |
| 278 | virtual |
| 279 | { |
| 280 | vm.assertNotEqDecimal(left, right, decimals, err); |
| 281 | } |
| 282 | |
| 283 | function assertNotEq(int256 left, int256 right) internal pure virtual { |
| 284 | if (left == right) { |
| 285 | vm.assertNotEq(left, right); |
| 286 | } |
| 287 | } |
| 288 | |
| 289 | function assertNotEq(int256 left, int256 right, string memory err) internal pure virtual { |
| 290 | if (left == right) { |
| 291 | vm.assertNotEq(left, right, err); |
| 292 | } |
| 293 | } |
| 294 | |
| 295 | function assertNotEqDecimal(int256 left, int256 right, uint256 decimals) internal pure virtual { |
| 296 | vm.assertNotEqDecimal(left, right, decimals); |
| 297 | } |
| 298 | |
| 299 | function assertNotEqDecimal(int256 left, int256 right, uint256 decimals, string memory err) internal pure virtual { |
| 300 | vm.assertNotEqDecimal(left, right, decimals, err); |
| 301 | } |
| 302 | |
| 303 | function assertNotEq(address left, address right) internal pure virtual { |
| 304 | if (left == right) { |
| 305 | vm.assertNotEq(left, right); |
| 306 | } |
| 307 | } |
| 308 | |
| 309 | function assertNotEq(address left, address right, string memory err) internal pure virtual { |
| 310 | if (left == right) { |
| 311 | vm.assertNotEq(left, right, err); |
| 312 | } |
| 313 | } |
| 314 | |
| 315 | function assertNotEq(bytes32 left, bytes32 right) internal pure virtual { |
| 316 | if (left == right) { |
| 317 | vm.assertNotEq(left, right); |
| 318 | } |
| 319 | } |
| 320 | |
| 321 | function assertNotEq(bytes32 left, bytes32 right, string memory err) internal pure virtual { |
| 322 | if (left == right) { |
| 323 | vm.assertNotEq(left, right, err); |
| 324 | } |
| 325 | } |
| 326 | |
| 327 | function assertNotEq32(bytes32 left, bytes32 right) internal pure virtual { |
| 328 | if (left == right) { |
| 329 | vm.assertNotEq(left, right); |
| 330 | } |
| 331 | } |
| 332 | |
| 333 | function assertNotEq32(bytes32 left, bytes32 right, string memory err) internal pure virtual { |
| 334 | if (left == right) { |
| 335 | vm.assertNotEq(left, right, err); |
| 336 | } |
| 337 | } |
| 338 | |
| 339 | function assertNotEq(string memory left, string memory right) internal pure virtual { |
| 340 | vm.assertNotEq(left, right); |
| 341 | } |
| 342 | |
| 343 | function assertNotEq(string memory left, string memory right, string memory err) internal pure virtual { |
| 344 | vm.assertNotEq(left, right, err); |
| 345 | } |
| 346 | |
| 347 | function assertNotEq(bytes memory left, bytes memory right) internal pure virtual { |
| 348 | vm.assertNotEq(left, right); |
| 349 | } |
| 350 | |
| 351 | function assertNotEq(bytes memory left, bytes memory right, string memory err) internal pure virtual { |
| 352 | vm.assertNotEq(left, right, err); |
| 353 | } |
| 354 | |
| 355 | function assertNotEq(bool[] memory left, bool[] memory right) internal pure virtual { |
| 356 | vm.assertNotEq(left, right); |
| 357 | } |
| 358 | |
| 359 | function assertNotEq(bool[] memory left, bool[] memory right, string memory err) internal pure virtual { |
| 360 | vm.assertNotEq(left, right, err); |
| 361 | } |
| 362 | |
| 363 | function assertNotEq(uint256[] memory left, uint256[] memory right) internal pure virtual { |
| 364 | vm.assertNotEq(left, right); |
| 365 | } |
| 366 | |
| 367 | function assertNotEq(uint256[] memory left, uint256[] memory right, string memory err) internal pure virtual { |
| 368 | vm.assertNotEq(left, right, err); |
| 369 | } |
| 370 | |
| 371 | function assertNotEq(int256[] memory left, int256[] memory right) internal pure virtual { |
| 372 | vm.assertNotEq(left, right); |
| 373 | } |
| 374 | |
| 375 | function assertNotEq(int256[] memory left, int256[] memory right, string memory err) internal pure virtual { |
| 376 | vm.assertNotEq(left, right, err); |
| 377 | } |
| 378 | |
| 379 | function assertNotEq(address[] memory left, address[] memory right) internal pure virtual { |
| 380 | vm.assertNotEq(left, right); |
| 381 | } |
| 382 | |
| 383 | function assertNotEq(address[] memory left, address[] memory right, string memory err) internal pure virtual { |
| 384 | vm.assertNotEq(left, right, err); |
| 385 | } |
| 386 | |
| 387 | function assertNotEq(bytes32[] memory left, bytes32[] memory right) internal pure virtual { |
| 388 | vm.assertNotEq(left, right); |
| 389 | } |
| 390 | |
| 391 | function assertNotEq(bytes32[] memory left, bytes32[] memory right, string memory err) internal pure virtual { |
| 392 | vm.assertNotEq(left, right, err); |
| 393 | } |
| 394 | |
| 395 | function assertNotEq(string[] memory left, string[] memory right) internal pure virtual { |
| 396 | vm.assertNotEq(left, right); |
| 397 | } |
| 398 | |
| 399 | function assertNotEq(string[] memory left, string[] memory right, string memory err) internal pure virtual { |
| 400 | vm.assertNotEq(left, right, err); |
| 401 | } |
| 402 | |
| 403 | function assertNotEq(bytes[] memory left, bytes[] memory right) internal pure virtual { |
| 404 | vm.assertNotEq(left, right); |
| 405 | } |
| 406 | |
| 407 | function assertNotEq(bytes[] memory left, bytes[] memory right, string memory err) internal pure virtual { |
| 408 | vm.assertNotEq(left, right, err); |
| 409 | } |
| 410 | |
| 411 | function assertLt(uint256 left, uint256 right) internal pure virtual { |
| 412 | if (left >= right) { |
| 413 | vm.assertLt(left, right); |
| 414 | } |
| 415 | } |
| 416 | |
| 417 | function assertLt(uint256 left, uint256 right, string memory err) internal pure virtual { |
| 418 | if (left >= right) { |
| 419 | vm.assertLt(left, right, err); |
| 420 | } |
| 421 | } |
| 422 | |
| 423 | function assertLtDecimal(uint256 left, uint256 right, uint256 decimals) internal pure virtual { |
| 424 | vm.assertLtDecimal(left, right, decimals); |
| 425 | } |
| 426 | |
| 427 | function assertLtDecimal(uint256 left, uint256 right, uint256 decimals, string memory err) internal pure virtual { |
| 428 | vm.assertLtDecimal(left, right, decimals, err); |
| 429 | } |
| 430 | |
| 431 | function assertLt(int256 left, int256 right) internal pure virtual { |
| 432 | if (left >= right) { |
| 433 | vm.assertLt(left, right); |
| 434 | } |
| 435 | } |
| 436 | |
| 437 | function assertLt(int256 left, int256 right, string memory err) internal pure virtual { |
| 438 | if (left >= right) { |
| 439 | vm.assertLt(left, right, err); |
| 440 | } |
| 441 | } |
| 442 | |
| 443 | function assertLtDecimal(int256 left, int256 right, uint256 decimals) internal pure virtual { |
| 444 | vm.assertLtDecimal(left, right, decimals); |
| 445 | } |
| 446 | |
| 447 | function assertLtDecimal(int256 left, int256 right, uint256 decimals, string memory err) internal pure virtual { |
| 448 | vm.assertLtDecimal(left, right, decimals, err); |
| 449 | } |
| 450 | |
| 451 | function assertGt(uint256 left, uint256 right) internal pure virtual { |
| 452 | if (left <= right) { |
| 453 | vm.assertGt(left, right); |
| 454 | } |
| 455 | } |
| 456 | |
| 457 | function assertGt(uint256 left, uint256 right, string memory err) internal pure virtual { |
| 458 | if (left <= right) { |
| 459 | vm.assertGt(left, right, err); |
| 460 | } |
| 461 | } |
| 462 | |
| 463 | function assertGtDecimal(uint256 left, uint256 right, uint256 decimals) internal pure virtual { |
| 464 | vm.assertGtDecimal(left, right, decimals); |
| 465 | } |
| 466 | |
| 467 | function assertGtDecimal(uint256 left, uint256 right, uint256 decimals, string memory err) internal pure virtual { |
| 468 | vm.assertGtDecimal(left, right, decimals, err); |
| 469 | } |
| 470 | |
| 471 | function assertGt(int256 left, int256 right) internal pure virtual { |
| 472 | if (left <= right) { |
| 473 | vm.assertGt(left, right); |
| 474 | } |
| 475 | } |
| 476 | |
| 477 | function assertGt(int256 left, int256 right, string memory err) internal pure virtual { |
| 478 | if (left <= right) { |
| 479 | vm.assertGt(left, right, err); |
| 480 | } |
| 481 | } |
| 482 | |
| 483 | function assertGtDecimal(int256 left, int256 right, uint256 decimals) internal pure virtual { |
| 484 | vm.assertGtDecimal(left, right, decimals); |
| 485 | } |
| 486 | |
| 487 | function assertGtDecimal(int256 left, int256 right, uint256 decimals, string memory err) internal pure virtual { |
| 488 | vm.assertGtDecimal(left, right, decimals, err); |
| 489 | } |
| 490 | |
| 491 | function assertLe(uint256 left, uint256 right) internal pure virtual { |
| 492 | if (left > right) { |
| 493 | vm.assertLe(left, right); |
| 494 | } |
| 495 | } |
| 496 | |
| 497 | function assertLe(uint256 left, uint256 right, string memory err) internal pure virtual { |
| 498 | if (left > right) { |
| 499 | vm.assertLe(left, right, err); |
| 500 | } |
| 501 | } |
| 502 | |
| 503 | function assertLeDecimal(uint256 left, uint256 right, uint256 decimals) internal pure virtual { |
| 504 | vm.assertLeDecimal(left, right, decimals); |
| 505 | } |
| 506 | |
| 507 | function assertLeDecimal(uint256 left, uint256 right, uint256 decimals, string memory err) internal pure virtual { |
| 508 | vm.assertLeDecimal(left, right, decimals, err); |
| 509 | } |
| 510 | |
| 511 | function assertLe(int256 left, int256 right) internal pure virtual { |
| 512 | if (left > right) { |
| 513 | vm.assertLe(left, right); |
| 514 | } |
| 515 | } |
| 516 | |
| 517 | function assertLe(int256 left, int256 right, string memory err) internal pure virtual { |
| 518 | if (left > right) { |
| 519 | vm.assertLe(left, right, err); |
| 520 | } |
| 521 | } |
| 522 | |
| 523 | function assertLeDecimal(int256 left, int256 right, uint256 decimals) internal pure virtual { |
| 524 | vm.assertLeDecimal(left, right, decimals); |
| 525 | } |
| 526 | |
| 527 | function assertLeDecimal(int256 left, int256 right, uint256 decimals, string memory err) internal pure virtual { |
| 528 | vm.assertLeDecimal(left, right, decimals, err); |
| 529 | } |
| 530 | |
| 531 | function assertGe(uint256 left, uint256 right) internal pure virtual { |
| 532 | if (left < right) { |
| 533 | vm.assertGe(left, right); |
| 534 | } |
| 535 | } |
| 536 | |
| 537 | function assertGe(uint256 left, uint256 right, string memory err) internal pure virtual { |
| 538 | if (left < right) { |
| 539 | vm.assertGe(left, right, err); |
| 540 | } |
| 541 | } |
| 542 | |
| 543 | function assertGeDecimal(uint256 left, uint256 right, uint256 decimals) internal pure virtual { |
| 544 | vm.assertGeDecimal(left, right, decimals); |
| 545 | } |
| 546 | |
| 547 | function assertGeDecimal(uint256 left, uint256 right, uint256 decimals, string memory err) internal pure virtual { |
| 548 | vm.assertGeDecimal(left, right, decimals, err); |
| 549 | } |
| 550 | |
| 551 | function assertGe(int256 left, int256 right) internal pure virtual { |
| 552 | if (left < right) { |
| 553 | vm.assertGe(left, right); |
| 554 | } |
| 555 | } |
| 556 | |
| 557 | function assertGe(int256 left, int256 right, string memory err) internal pure virtual { |
| 558 | if (left < right) { |
| 559 | vm.assertGe(left, right, err); |
| 560 | } |
| 561 | } |
| 562 | |
| 563 | function assertGeDecimal(int256 left, int256 right, uint256 decimals) internal pure virtual { |
| 564 | vm.assertGeDecimal(left, right, decimals); |
| 565 | } |
| 566 | |
| 567 | function assertGeDecimal(int256 left, int256 right, uint256 decimals, string memory err) internal pure virtual { |
| 568 | vm.assertGeDecimal(left, right, decimals, err); |
| 569 | } |
| 570 | |
| 571 | function assertApproxEqAbs(uint256 left, uint256 right, uint256 maxDelta) internal pure virtual { |
| 572 | vm.assertApproxEqAbs(left, right, maxDelta); |
| 573 | } |
| 574 | |
| 575 | function assertApproxEqAbs(uint256 left, uint256 right, uint256 maxDelta, string memory err) internal pure virtual { |
| 576 | vm.assertApproxEqAbs(left, right, maxDelta, err); |
| 577 | } |
| 578 | |
| 579 | function assertApproxEqAbsDecimal(uint256 left, uint256 right, uint256 maxDelta, uint256 decimals) |
| 580 | internal |
| 581 | pure |
| 582 | virtual |
| 583 | { |
| 584 | vm.assertApproxEqAbsDecimal(left, right, maxDelta, decimals); |
| 585 | } |
| 586 | |
| 587 | function assertApproxEqAbsDecimal( |
| 588 | uint256 left, |
| 589 | uint256 right, |
| 590 | uint256 maxDelta, |
| 591 | uint256 decimals, |
| 592 | string memory err |
| 593 | ) internal pure virtual { |
| 594 | vm.assertApproxEqAbsDecimal(left, right, maxDelta, decimals, err); |
| 595 | } |
| 596 | |
| 597 | function assertApproxEqAbs(int256 left, int256 right, uint256 maxDelta) internal pure virtual { |
| 598 | vm.assertApproxEqAbs(left, right, maxDelta); |
| 599 | } |
| 600 | |
| 601 | function assertApproxEqAbs(int256 left, int256 right, uint256 maxDelta, string memory err) internal pure virtual { |
| 602 | vm.assertApproxEqAbs(left, right, maxDelta, err); |
| 603 | } |
| 604 | |
| 605 | function assertApproxEqAbsDecimal(int256 left, int256 right, uint256 maxDelta, uint256 decimals) |
| 606 | internal |
| 607 | pure |
| 608 | virtual |
| 609 | { |
| 610 | vm.assertApproxEqAbsDecimal(left, right, maxDelta, decimals); |
| 611 | } |
| 612 | |
| 613 | function assertApproxEqAbsDecimal(int256 left, int256 right, uint256 maxDelta, uint256 decimals, string memory err) |
| 614 | internal |
| 615 | pure |
| 616 | virtual |
| 617 | { |
| 618 | vm.assertApproxEqAbsDecimal(left, right, maxDelta, decimals, err); |
| 619 | } |
| 620 | |
| 621 | function assertApproxEqRel( |
| 622 | uint256 left, |
| 623 | uint256 right, |
| 624 | uint256 maxPercentDelta // An 18 decimal fixed point number, where 1e18 == 100% |
| 625 | ) |
| 626 | internal |
| 627 | pure |
| 628 | virtual |
| 629 | { |
| 630 | vm.assertApproxEqRel(left, right, maxPercentDelta); |
| 631 | } |
| 632 | |
| 633 | function assertApproxEqRel( |
| 634 | uint256 left, |
| 635 | uint256 right, |
| 636 | uint256 maxPercentDelta, // An 18 decimal fixed point number, where 1e18 == 100% |
| 637 | string memory err |
| 638 | ) |
| 639 | internal |
| 640 | pure |
| 641 | virtual |
| 642 | { |
| 643 | vm.assertApproxEqRel(left, right, maxPercentDelta, err); |
| 644 | } |
| 645 | |
| 646 | function assertApproxEqRelDecimal( |
| 647 | uint256 left, |
| 648 | uint256 right, |
| 649 | uint256 maxPercentDelta, // An 18 decimal fixed point number, where 1e18 == 100% |
| 650 | uint256 decimals |
| 651 | ) |
| 652 | internal |
| 653 | pure |
| 654 | virtual |
| 655 | { |
| 656 | vm.assertApproxEqRelDecimal(left, right, maxPercentDelta, decimals); |
| 657 | } |
| 658 | |
| 659 | function assertApproxEqRelDecimal( |
| 660 | uint256 left, |
| 661 | uint256 right, |
| 662 | uint256 maxPercentDelta, // An 18 decimal fixed point number, where 1e18 == 100% |
| 663 | uint256 decimals, |
| 664 | string memory err |
| 665 | ) internal pure virtual { |
| 666 | vm.assertApproxEqRelDecimal(left, right, maxPercentDelta, decimals, err); |
| 667 | } |
| 668 | |
| 669 | function assertApproxEqRel(int256 left, int256 right, uint256 maxPercentDelta) internal pure virtual { |
| 670 | vm.assertApproxEqRel(left, right, maxPercentDelta); |
| 671 | } |
| 672 | |
| 673 | function assertApproxEqRel( |
| 674 | int256 left, |
| 675 | int256 right, |
| 676 | uint256 maxPercentDelta, // An 18 decimal fixed point number, where 1e18 == 100% |
| 677 | string memory err |
| 678 | ) |
| 679 | internal |
| 680 | pure |
| 681 | virtual |
| 682 | { |
| 683 | vm.assertApproxEqRel(left, right, maxPercentDelta, err); |
| 684 | } |
| 685 | |
| 686 | function assertApproxEqRelDecimal( |
| 687 | int256 left, |
| 688 | int256 right, |
| 689 | uint256 maxPercentDelta, // An 18 decimal fixed point number, where 1e18 == 100% |
| 690 | uint256 decimals |
| 691 | ) |
| 692 | internal |
| 693 | pure |
| 694 | virtual |
| 695 | { |
| 696 | vm.assertApproxEqRelDecimal(left, right, maxPercentDelta, decimals); |
| 697 | } |
| 698 | |
| 699 | function assertApproxEqRelDecimal( |
| 700 | int256 left, |
| 701 | int256 right, |
| 702 | uint256 maxPercentDelta, // An 18 decimal fixed point number, where 1e18 == 100% |
| 703 | uint256 decimals, |
| 704 | string memory err |
| 705 | ) internal pure virtual { |
| 706 | vm.assertApproxEqRelDecimal(left, right, maxPercentDelta, decimals, err); |
| 707 | } |
| 708 | |
| 709 | // Inherited from DSTest, not used but kept for backwards-compatibility |
| 710 | function checkEq0(bytes memory left, bytes memory right) internal pure returns (bool) { |
| 711 | return keccak256(left) == keccak256(right); |
| 712 | } |
| 713 | |
| 714 | function assertEq0(bytes memory left, bytes memory right) internal pure virtual { |
| 715 | assertEq(left, right); |
| 716 | } |
| 717 | |
| 718 | function assertEq0(bytes memory left, bytes memory right, string memory err) internal pure virtual { |
| 719 | assertEq(left, right, err); |
| 720 | } |
| 721 | |
| 722 | function assertNotEq0(bytes memory left, bytes memory right) internal pure virtual { |
| 723 | assertNotEq(left, right); |
| 724 | } |
| 725 | |
| 726 | function assertNotEq0(bytes memory left, bytes memory right, string memory err) internal pure virtual { |
| 727 | assertNotEq(left, right, err); |
| 728 | } |
| 729 | |
| 730 | function assertEqCall(address target, bytes memory callDataA, bytes memory callDataB) internal virtual { |
| 731 | assertEqCall(target, callDataA, target, callDataB, true); |
| 732 | } |
| 733 | |
| 734 | function assertEqCall(address targetA, bytes memory callDataA, address targetB, bytes memory callDataB) |
| 735 | internal |
| 736 | virtual |
| 737 | { |
| 738 | assertEqCall(targetA, callDataA, targetB, callDataB, true); |
| 739 | } |
| 740 | |
| 741 | function assertEqCall(address target, bytes memory callDataA, bytes memory callDataB, bool strictRevertData) |
| 742 | internal |
| 743 | virtual |
| 744 | { |
| 745 | assertEqCall(target, callDataA, target, callDataB, strictRevertData); |
| 746 | } |
| 747 | |
| 748 | function assertEqCall( |
| 749 | address targetA, |
| 750 | bytes memory callDataA, |
| 751 | address targetB, |
| 752 | bytes memory callDataB, |
| 753 | bool strictRevertData |
| 754 | ) internal virtual { |
| 755 | (bool successA, bytes memory returnDataA) = address(targetA).call(callDataA); |
| 756 | (bool successB, bytes memory returnDataB) = address(targetB).call(callDataB); |
| 757 | |
| 758 | if (successA && successB) { |
| 759 | assertEq(returnDataA, returnDataB, "Call return data does not match"); |
| 760 | } |
| 761 | |
| 762 | if (!successA && !successB && strictRevertData) { |
| 763 | assertEq(returnDataA, returnDataB, "Call revert data does not match"); |
| 764 | } |
| 765 | |
| 766 | if (!successA && successB) { |
| 767 | emit log("Error: Calls were not equal"); |
| 768 | emit log_named_bytes(" Left call revert data", returnDataA); |
| 769 | emit log_named_bytes(" Right call return data", returnDataB); |
| 770 | revert("assertion failed"); |
| 771 | } |
| 772 | |
| 773 | if (successA && !successB) { |
| 774 | emit log("Error: Calls were not equal"); |
| 775 | emit log_named_bytes(" Left call return data", returnDataA); |
| 776 | emit log_named_bytes(" Right call revert data", returnDataB); |
| 777 | revert("assertion failed"); |
| 778 | } |
| 779 | } |
| 780 | } |
| 781 |
100.0%
lib/forge-std/src/StdChains.sol
Lines covered: 1 / 1 (100.0%)
| 1 | // SPDX-License-Identifier: MIT |
| 2 | pragma solidity >=0.6.2 <0.9.0; |
| 3 | pragma experimental ABIEncoderV2; |
| 4 | |
| 5 | import {VmSafe} from "./Vm.sol"; |
| 6 | |
| 7 | /** |
| 8 | * StdChains provides information about EVM compatible chains that can be used in scripts/tests. |
| 9 | * For each chain, the chain's name, chain ID, and a default RPC URL are provided. Chains are |
| 10 | * identified by their alias, which is the same as the alias in the `[rpc_endpoints]` section of |
| 11 | * the `foundry.toml` file. For best UX, ensure the alias in the `foundry.toml` file match the |
| 12 | * alias used in this contract, which can be found as the first argument to the |
| 13 | * `setChainWithDefaultRpcUrl` call in the `initializeStdChains` function. |
| 14 | * |
| 15 | * There are two main ways to use this contract: |
| 16 | * 1. Set a chain with `setChain(string memory chainAlias, ChainData memory chain)` or |
| 17 | * `setChain(string memory chainAlias, Chain memory chain)` |
| 18 | * 2. Get a chain with `getChain(string memory chainAlias)` or `getChain(uint256 chainId)`. |
| 19 | * |
| 20 | * The first time either of those are used, chains are initialized with the default set of RPC URLs. |
| 21 | * This is done in `initializeStdChains`, which uses `setChainWithDefaultRpcUrl`. Defaults are recorded in |
| 22 | * `defaultRpcUrls`. |
| 23 | * |
| 24 | * The `setChain` function is straightforward, and it simply saves off the given chain data. |
| 25 | * |
| 26 | * The `getChain` methods use `getChainWithUpdatedRpcUrl` to return a chain. For example, let's say |
| 27 | * we want to retrieve the RPC URL for `mainnet`: |
| 28 | * - If you have specified data with `setChain`, it will return that. |
| 29 | * - If you have configured a mainnet RPC URL in `foundry.toml`, it will return the URL, provided it |
| 30 | * is valid (e.g. a URL is specified, or an environment variable is given and exists). |
| 31 | * - If neither of the above conditions is met, the default data is returned. |
| 32 | * |
| 33 | * Summarizing the above, the prioritization hierarchy is `setChain` -> `foundry.toml` -> environment variable -> defaults. |
| 34 | */ |
| 35 | abstract contract StdChains { |
| 36 | VmSafe private constant vm = VmSafe(address(uint160(uint256(keccak256("hevm cheat code"))))); |
| 37 | |
| 38 | bool private stdChainsInitialized; |
| 39 | |
| 40 | struct ChainData { |
| 41 | string name; |
| 42 | uint256 chainId; |
| 43 | string rpcUrl; |
| 44 | } |
| 45 | |
| 46 | struct Chain { |
| 47 | // The chain name. |
| 48 | string name; |
| 49 | // The chain's Chain ID. |
| 50 | uint256 chainId; |
| 51 | // The chain's alias. (i.e. what gets specified in `foundry.toml`). |
| 52 | string chainAlias; |
| 53 | // A default RPC endpoint for this chain. |
| 54 | // NOTE: This default RPC URL is included for convenience to facilitate quick tests and |
| 55 | // experimentation. Do not use this RPC URL for production test suites, CI, or other heavy |
| 56 | // usage as you will be throttled and this is a disservice to others who need this endpoint. |
| 57 | string rpcUrl; |
| 58 | } |
| 59 | |
| 60 | // Maps from the chain's alias (matching the alias in the `foundry.toml` file) to chain data. |
| 61 | mapping(string => Chain) private chains; |
| 62 | // Maps from the chain's alias to it's default RPC URL. |
| 63 | mapping(string => string) private defaultRpcUrls; |
| 64 | // Maps from a chain ID to it's alias. |
| 65 | mapping(uint256 => string) private idToAlias; |
| 66 | |
| 67 | bool private fallbackToDefaultRpcUrls = true; |
| 68 | |
| 69 | // The RPC URL will be fetched from config or defaultRpcUrls if possible. |
| 70 | function getChain(string memory chainAlias) internal virtual returns (Chain memory chain) { |
| 71 | require(bytes(chainAlias).length != 0, "StdChains getChain(string): Chain alias cannot be the empty string."); |
| 72 | |
| 73 | initializeStdChains(); |
| 74 | chain = chains[chainAlias]; |
| 75 | require( |
| 76 | chain.chainId != 0, |
| 77 | string(abi.encodePacked("StdChains getChain(string): Chain with alias \"", chainAlias, "\" not found.")) |
| 78 | ); |
| 79 | |
| 80 | chain = getChainWithUpdatedRpcUrl(chainAlias, chain); |
| 81 | } |
| 82 | |
| 83 | function getChain(uint256 chainId) internal virtual returns (Chain memory chain) { |
| 84 | require(chainId != 0, "StdChains getChain(uint256): Chain ID cannot be 0."); |
| 85 | initializeStdChains(); |
| 86 | string memory chainAlias = idToAlias[chainId]; |
| 87 | |
| 88 | chain = chains[chainAlias]; |
| 89 | |
| 90 | require( |
| 91 | chain.chainId != 0, |
| 92 | string(abi.encodePacked("StdChains getChain(uint256): Chain with ID ", vm.toString(chainId), " not found.")) |
| 93 | ); |
| 94 | |
| 95 | chain = getChainWithUpdatedRpcUrl(chainAlias, chain); |
| 96 | } |
| 97 | |
| 98 | // set chain info, with priority to argument's rpcUrl field. |
| 99 | function setChain(string memory chainAlias, ChainData memory chain) internal virtual { |
| 100 | require( |
| 101 | bytes(chainAlias).length != 0, |
| 102 | "StdChains setChain(string,ChainData): Chain alias cannot be the empty string." |
| 103 | ); |
| 104 | |
| 105 | require(chain.chainId != 0, "StdChains setChain(string,ChainData): Chain ID cannot be 0."); |
| 106 | |
| 107 | initializeStdChains(); |
| 108 | string memory foundAlias = idToAlias[chain.chainId]; |
| 109 | |
| 110 | require( |
| 111 | bytes(foundAlias).length == 0 || keccak256(bytes(foundAlias)) == keccak256(bytes(chainAlias)), |
| 112 | string( |
| 113 | abi.encodePacked( |
| 114 | "StdChains setChain(string,ChainData): Chain ID ", |
| 115 | vm.toString(chain.chainId), |
| 116 | " already used by \"", |
| 117 | foundAlias, |
| 118 | "\"." |
| 119 | ) |
| 120 | ) |
| 121 | ); |
| 122 | |
| 123 | uint256 oldChainId = chains[chainAlias].chainId; |
| 124 | delete idToAlias[oldChainId]; |
| 125 | |
| 126 | chains[chainAlias] = |
| 127 | Chain({name: chain.name, chainId: chain.chainId, chainAlias: chainAlias, rpcUrl: chain.rpcUrl}); |
| 128 | idToAlias[chain.chainId] = chainAlias; |
| 129 | } |
| 130 | |
| 131 | // set chain info, with priority to argument's rpcUrl field. |
| 132 | function setChain(string memory chainAlias, Chain memory chain) internal virtual { |
| 133 | setChain(chainAlias, ChainData({name: chain.name, chainId: chain.chainId, rpcUrl: chain.rpcUrl})); |
| 134 | } |
| 135 | |
| 136 | function _toUpper(string memory str) private pure returns (string memory) { |
| 137 | bytes memory strb = bytes(str); |
| 138 | bytes memory copy = new bytes(strb.length); |
| 139 | for (uint256 i = 0; i < strb.length; i++) { |
| 140 | bytes1 b = strb[i]; |
| 141 | if (b >= 0x61 && b <= 0x7A) { |
| 142 | copy[i] = bytes1(uint8(b) - 32); |
| 143 | } else { |
| 144 | copy[i] = b; |
| 145 | } |
| 146 | } |
| 147 | return string(copy); |
| 148 | } |
| 149 | |
| 150 | // lookup rpcUrl, in descending order of priority: |
| 151 | // current -> config (foundry.toml) -> environment variable -> default |
| 152 | function getChainWithUpdatedRpcUrl(string memory chainAlias, Chain memory chain) |
| 153 | private |
| 154 | view |
| 155 | returns (Chain memory) |
| 156 | { |
| 157 | if (bytes(chain.rpcUrl).length == 0) { |
| 158 | try vm.rpcUrl(chainAlias) returns (string memory configRpcUrl) { |
| 159 | chain.rpcUrl = configRpcUrl; |
| 160 | } catch (bytes memory err) { |
| 161 | string memory envName = string(abi.encodePacked(_toUpper(chainAlias), "_RPC_URL")); |
| 162 | if (fallbackToDefaultRpcUrls) { |
| 163 | chain.rpcUrl = vm.envOr(envName, defaultRpcUrls[chainAlias]); |
| 164 | } else { |
| 165 | chain.rpcUrl = vm.envString(envName); |
| 166 | } |
| 167 | // Distinguish 'not found' from 'cannot read' |
| 168 | // The upstream error thrown by forge for failing cheats changed so we check both the old and new versions |
| 169 | bytes memory oldNotFoundError = |
| 170 | abi.encodeWithSignature("CheatCodeError", string(abi.encodePacked("invalid rpc url ", chainAlias))); |
| 171 | bytes memory newNotFoundError = abi.encodeWithSignature( |
| 172 | "CheatcodeError(string)", string(abi.encodePacked("invalid rpc url: ", chainAlias)) |
| 173 | ); |
| 174 | bytes32 errHash = keccak256(err); |
| 175 | if ( |
| 176 | (errHash != keccak256(oldNotFoundError) && errHash != keccak256(newNotFoundError)) |
| 177 | || bytes(chain.rpcUrl).length == 0 |
| 178 | ) { |
| 179 | /// @solidity memory-safe-assembly |
| 180 | assembly { |
| 181 | revert(add(32, err), mload(err)) |
| 182 | } |
| 183 | } |
| 184 | } |
| 185 | } |
| 186 | return chain; |
| 187 | } |
| 188 | |
| 189 | function setFallbackToDefaultRpcUrls(bool useDefault) internal { |
| 190 | fallbackToDefaultRpcUrls = useDefault; |
| 191 | } |
| 192 | |
| 193 | function initializeStdChains() private { |
| 194 | if (stdChainsInitialized) return; |
| 195 | |
| 196 | stdChainsInitialized = true; |
| 197 | |
| 198 | // If adding an RPC here, make sure to test the default RPC URL in `test_Rpcs` in `StdChains.t.sol` |
| 199 | setChainWithDefaultRpcUrl("anvil", ChainData("Anvil", 31337, "http://127.0.0.1:8545")); |
| 200 | setChainWithDefaultRpcUrl("mainnet", ChainData("Mainnet", 1, "https://eth.llamarpc.com")); |
| 201 | setChainWithDefaultRpcUrl( |
| 202 | "sepolia", ChainData("Sepolia", 11155111, "https://sepolia.infura.io/v3/b9794ad1ddf84dfb8c34d6bb5dca2001") |
| 203 | ); |
| 204 | setChainWithDefaultRpcUrl("holesky", ChainData("Holesky", 17000, "https://rpc.holesky.ethpandaops.io")); |
| 205 | setChainWithDefaultRpcUrl("hoodi", ChainData("Hoodi", 560048, "https://rpc.hoodi.ethpandaops.io")); |
| 206 | setChainWithDefaultRpcUrl("optimism", ChainData("Optimism", 10, "https://mainnet.optimism.io")); |
| 207 | setChainWithDefaultRpcUrl( |
| 208 | "optimism_sepolia", ChainData("Optimism Sepolia", 11155420, "https://sepolia.optimism.io") |
| 209 | ); |
| 210 | setChainWithDefaultRpcUrl("arbitrum_one", ChainData("Arbitrum One", 42161, "https://arb1.arbitrum.io/rpc")); |
| 211 | setChainWithDefaultRpcUrl( |
| 212 | "arbitrum_one_sepolia", ChainData("Arbitrum One Sepolia", 421614, "https://sepolia-rollup.arbitrum.io/rpc") |
| 213 | ); |
| 214 | setChainWithDefaultRpcUrl("arbitrum_nova", ChainData("Arbitrum Nova", 42170, "https://nova.arbitrum.io/rpc")); |
| 215 | setChainWithDefaultRpcUrl("polygon", ChainData("Polygon", 137, "https://polygon-rpc.com")); |
| 216 | setChainWithDefaultRpcUrl( |
| 217 | "polygon_amoy", ChainData("Polygon Amoy", 80002, "https://rpc-amoy.polygon.technology") |
| 218 | ); |
| 219 | setChainWithDefaultRpcUrl("avalanche", ChainData("Avalanche", 43114, "https://api.avax.network/ext/bc/C/rpc")); |
| 220 | setChainWithDefaultRpcUrl( |
| 221 | "avalanche_fuji", ChainData("Avalanche Fuji", 43113, "https://api.avax-test.network/ext/bc/C/rpc") |
| 222 | ); |
| 223 | setChainWithDefaultRpcUrl( |
| 224 | "bnb_smart_chain", ChainData("BNB Smart Chain", 56, "https://bsc-dataseed1.binance.org") |
| 225 | ); |
| 226 | setChainWithDefaultRpcUrl( |
| 227 | "bnb_smart_chain_testnet", |
| 228 | ChainData("BNB Smart Chain Testnet", 97, "https://rpc.ankr.com/bsc_testnet_chapel") |
| 229 | ); |
| 230 | setChainWithDefaultRpcUrl("gnosis_chain", ChainData("Gnosis Chain", 100, "https://rpc.gnosischain.com")); |
| 231 | setChainWithDefaultRpcUrl("moonbeam", ChainData("Moonbeam", 1284, "https://rpc.api.moonbeam.network")); |
| 232 | setChainWithDefaultRpcUrl( |
| 233 | "moonriver", ChainData("Moonriver", 1285, "https://rpc.api.moonriver.moonbeam.network") |
| 234 | ); |
| 235 | setChainWithDefaultRpcUrl("moonbase", ChainData("Moonbase", 1287, "https://rpc.testnet.moonbeam.network")); |
| 236 | setChainWithDefaultRpcUrl("base_sepolia", ChainData("Base Sepolia", 84532, "https://sepolia.base.org")); |
| 237 | setChainWithDefaultRpcUrl("base", ChainData("Base", 8453, "https://mainnet.base.org")); |
| 238 | setChainWithDefaultRpcUrl("blast_sepolia", ChainData("Blast Sepolia", 168587773, "https://sepolia.blast.io")); |
| 239 | setChainWithDefaultRpcUrl("blast", ChainData("Blast", 81457, "https://rpc.blast.io")); |
| 240 | setChainWithDefaultRpcUrl("fantom_opera", ChainData("Fantom Opera", 250, "https://rpc.ankr.com/fantom/")); |
| 241 | setChainWithDefaultRpcUrl( |
| 242 | "fantom_opera_testnet", ChainData("Fantom Opera Testnet", 4002, "https://rpc.ankr.com/fantom_testnet/") |
| 243 | ); |
| 244 | setChainWithDefaultRpcUrl("fraxtal", ChainData("Fraxtal", 252, "https://rpc.frax.com")); |
| 245 | setChainWithDefaultRpcUrl("fraxtal_testnet", ChainData("Fraxtal Testnet", 2522, "https://rpc.testnet.frax.com")); |
| 246 | setChainWithDefaultRpcUrl( |
| 247 | "berachain_bartio_testnet", ChainData("Berachain bArtio Testnet", 80084, "https://bartio.rpc.berachain.com") |
| 248 | ); |
| 249 | setChainWithDefaultRpcUrl("flare", ChainData("Flare", 14, "https://flare-api.flare.network/ext/C/rpc")); |
| 250 | setChainWithDefaultRpcUrl( |
| 251 | "flare_coston2", ChainData("Flare Coston2", 114, "https://coston2-api.flare.network/ext/C/rpc") |
| 252 | ); |
| 253 | |
| 254 | setChainWithDefaultRpcUrl("mode", ChainData("Mode", 34443, "https://mode.drpc.org")); |
| 255 | setChainWithDefaultRpcUrl("mode_sepolia", ChainData("Mode Sepolia", 919, "https://sepolia.mode.network")); |
| 256 | |
| 257 | setChainWithDefaultRpcUrl("zora", ChainData("Zora", 7777777, "https://zora.drpc.org")); |
| 258 | setChainWithDefaultRpcUrl( |
| 259 | "zora_sepolia", ChainData("Zora Sepolia", 999999999, "https://sepolia.rpc.zora.energy") |
| 260 | ); |
| 261 | |
| 262 | setChainWithDefaultRpcUrl("race", ChainData("Race", 6805, "https://racemainnet.io")); |
| 263 | setChainWithDefaultRpcUrl("race_sepolia", ChainData("Race Sepolia", 6806, "https://racemainnet.io")); |
| 264 | |
| 265 | setChainWithDefaultRpcUrl("metal", ChainData("Metal", 1750, "https://metall2.drpc.org")); |
| 266 | setChainWithDefaultRpcUrl("metal_sepolia", ChainData("Metal Sepolia", 1740, "https://testnet.rpc.metall2.com")); |
| 267 | |
| 268 | setChainWithDefaultRpcUrl("binary", ChainData("Binary", 624, "https://rpc.zero.thebinaryholdings.com")); |
| 269 | setChainWithDefaultRpcUrl( |
| 270 | "binary_sepolia", ChainData("Binary Sepolia", 625, "https://rpc.zero.thebinaryholdings.com") |
| 271 | ); |
| 272 | |
| 273 | setChainWithDefaultRpcUrl("orderly", ChainData("Orderly", 291, "https://rpc.orderly.network")); |
| 274 | setChainWithDefaultRpcUrl( |
| 275 | "orderly_sepolia", ChainData("Orderly Sepolia", 4460, "https://testnet-rpc.orderly.org") |
| 276 | ); |
| 277 | |
| 278 | setChainWithDefaultRpcUrl("unichain", ChainData("Unichain", 130, "https://mainnet.unichain.org")); |
| 279 | setChainWithDefaultRpcUrl( |
| 280 | "unichain_sepolia", ChainData("Unichain Sepolia", 1301, "https://sepolia.unichain.org") |
| 281 | ); |
| 282 | } |
| 283 | |
| 284 | // set chain info, with priority to chainAlias' rpc url in foundry.toml |
| 285 | function setChainWithDefaultRpcUrl(string memory chainAlias, ChainData memory chain) private { |
| 286 | string memory rpcUrl = chain.rpcUrl; |
| 287 | defaultRpcUrls[chainAlias] = rpcUrl; |
| 288 | chain.rpcUrl = ""; |
| 289 | setChain(chainAlias, chain); |
| 290 | chain.rpcUrl = rpcUrl; // restore argument |
| 291 | } |
| 292 | } |
| 293 |
100.0%
lib/forge-std/src/StdCheats.sol
Lines covered: 4 / 4 (100.0%)
| 1 | // SPDX-License-Identifier: MIT |
| 2 | pragma solidity >=0.6.2 <0.9.0; |
| 3 | |
| 4 | pragma experimental ABIEncoderV2; |
| 5 | |
| 6 | import {StdStorage, stdStorage} from "./StdStorage.sol"; |
| 7 | import {console2} from "./console2.sol"; |
| 8 | import {Vm} from "./Vm.sol"; |
| 9 | |
| 10 | abstract contract StdCheatsSafe { |
| 11 | Vm private constant vm = Vm(address(uint160(uint256(keccak256("hevm cheat code"))))); |
| 12 | |
| 13 | uint256 private constant UINT256_MAX = |
| 14 | 115792089237316195423570985008687907853269984665640564039457584007913129639935; |
| 15 | |
| 16 | bool private gasMeteringOff; |
| 17 | |
| 18 | // Data structures to parse Transaction objects from the broadcast artifact |
| 19 | // that conform to EIP1559. The Raw structs is what is parsed from the JSON |
| 20 | // and then converted to the one that is used by the user for better UX. |
| 21 | |
| 22 | struct RawTx1559 { |
| 23 | string[] arguments; |
| 24 | address contractAddress; |
| 25 | string contractName; |
| 26 | // json value name = function |
| 27 | string functionSig; |
| 28 | bytes32 hash; |
| 29 | // json value name = tx |
| 30 | RawTx1559Detail txDetail; |
| 31 | // json value name = type |
| 32 | string opcode; |
| 33 | } |
| 34 | |
| 35 | struct RawTx1559Detail { |
| 36 | AccessList[] accessList; |
| 37 | bytes data; |
| 38 | address from; |
| 39 | bytes gas; |
| 40 | bytes nonce; |
| 41 | address to; |
| 42 | bytes txType; |
| 43 | bytes value; |
| 44 | } |
| 45 | |
| 46 | struct Tx1559 { |
| 47 | string[] arguments; |
| 48 | address contractAddress; |
| 49 | string contractName; |
| 50 | string functionSig; |
| 51 | bytes32 hash; |
| 52 | Tx1559Detail txDetail; |
| 53 | string opcode; |
| 54 | } |
| 55 | |
| 56 | struct Tx1559Detail { |
| 57 | AccessList[] accessList; |
| 58 | bytes data; |
| 59 | address from; |
| 60 | uint256 gas; |
| 61 | uint256 nonce; |
| 62 | address to; |
| 63 | uint256 txType; |
| 64 | uint256 value; |
| 65 | } |
| 66 | |
| 67 | // Data structures to parse Transaction objects from the broadcast artifact |
| 68 | // that DO NOT conform to EIP1559. The Raw structs is what is parsed from the JSON |
| 69 | // and then converted to the one that is used by the user for better UX. |
| 70 | |
| 71 | struct TxLegacy { |
| 72 | string[] arguments; |
| 73 | address contractAddress; |
| 74 | string contractName; |
| 75 | string functionSig; |
| 76 | string hash; |
| 77 | string opcode; |
| 78 | TxDetailLegacy transaction; |
| 79 | } |
| 80 | |
| 81 | struct TxDetailLegacy { |
| 82 | AccessList[] accessList; |
| 83 | uint256 chainId; |
| 84 | bytes data; |
| 85 | address from; |
| 86 | uint256 gas; |
| 87 | uint256 gasPrice; |
| 88 | bytes32 hash; |
| 89 | uint256 nonce; |
| 90 | bytes1 opcode; |
| 91 | bytes32 r; |
| 92 | bytes32 s; |
| 93 | uint256 txType; |
| 94 | address to; |
| 95 | uint8 v; |
| 96 | uint256 value; |
| 97 | } |
| 98 | |
| 99 | struct AccessList { |
| 100 | address accessAddress; |
| 101 | bytes32[] storageKeys; |
| 102 | } |
| 103 | |
| 104 | // Data structures to parse Receipt objects from the broadcast artifact. |
| 105 | // The Raw structs is what is parsed from the JSON |
| 106 | // and then converted to the one that is used by the user for better UX. |
| 107 | |
| 108 | struct RawReceipt { |
| 109 | bytes32 blockHash; |
| 110 | bytes blockNumber; |
| 111 | address contractAddress; |
| 112 | bytes cumulativeGasUsed; |
| 113 | bytes effectiveGasPrice; |
| 114 | address from; |
| 115 | bytes gasUsed; |
| 116 | RawReceiptLog[] logs; |
| 117 | bytes logsBloom; |
| 118 | bytes status; |
| 119 | address to; |
| 120 | bytes32 transactionHash; |
| 121 | bytes transactionIndex; |
| 122 | } |
| 123 | |
| 124 | struct Receipt { |
| 125 | bytes32 blockHash; |
| 126 | uint256 blockNumber; |
| 127 | address contractAddress; |
| 128 | uint256 cumulativeGasUsed; |
| 129 | uint256 effectiveGasPrice; |
| 130 | address from; |
| 131 | uint256 gasUsed; |
| 132 | ReceiptLog[] logs; |
| 133 | bytes logsBloom; |
| 134 | uint256 status; |
| 135 | address to; |
| 136 | bytes32 transactionHash; |
| 137 | uint256 transactionIndex; |
| 138 | } |
| 139 | |
| 140 | // Data structures to parse the entire broadcast artifact, assuming the |
| 141 | // transactions conform to EIP1559. |
| 142 | |
| 143 | struct EIP1559ScriptArtifact { |
| 144 | string[] libraries; |
| 145 | string path; |
| 146 | string[] pending; |
| 147 | Receipt[] receipts; |
| 148 | uint256 timestamp; |
| 149 | Tx1559[] transactions; |
| 150 | TxReturn[] txReturns; |
| 151 | } |
| 152 | |
| 153 | struct RawEIP1559ScriptArtifact { |
| 154 | string[] libraries; |
| 155 | string path; |
| 156 | string[] pending; |
| 157 | RawReceipt[] receipts; |
| 158 | TxReturn[] txReturns; |
| 159 | uint256 timestamp; |
| 160 | RawTx1559[] transactions; |
| 161 | } |
| 162 | |
| 163 | struct RawReceiptLog { |
| 164 | // json value = address |
| 165 | address logAddress; |
| 166 | bytes32 blockHash; |
| 167 | bytes blockNumber; |
| 168 | bytes data; |
| 169 | bytes logIndex; |
| 170 | bool removed; |
| 171 | bytes32[] topics; |
| 172 | bytes32 transactionHash; |
| 173 | bytes transactionIndex; |
| 174 | bytes transactionLogIndex; |
| 175 | } |
| 176 | |
| 177 | struct ReceiptLog { |
| 178 | // json value = address |
| 179 | address logAddress; |
| 180 | bytes32 blockHash; |
| 181 | uint256 blockNumber; |
| 182 | bytes data; |
| 183 | uint256 logIndex; |
| 184 | bytes32[] topics; |
| 185 | uint256 transactionIndex; |
| 186 | uint256 transactionLogIndex; |
| 187 | bool removed; |
| 188 | } |
| 189 | |
| 190 | struct TxReturn { |
| 191 | string internalType; |
| 192 | string value; |
| 193 | } |
| 194 | |
| 195 | struct Account { |
| 196 | address addr; |
| 197 | uint256 key; |
| 198 | } |
| 199 | |
| 200 | enum AddressType { |
| 201 | Payable, |
| 202 | NonPayable, |
| 203 | ZeroAddress, |
| 204 | Precompile, |
| 205 | ForgeAddress |
| 206 | } |
| 207 | |
| 208 | // Checks that `addr` is not blacklisted by token contracts that have a blacklist. |
| 209 | function assumeNotBlacklisted(address token, address addr) internal view virtual { |
| 210 | // Nothing to check if `token` is not a contract. |
| 211 | uint256 tokenCodeSize; |
| 212 | assembly { |
| 213 | tokenCodeSize := extcodesize(token) |
| 214 | } |
| 215 | require(tokenCodeSize > 0, "StdCheats assumeNotBlacklisted(address,address): Token address is not a contract."); |
| 216 | |
| 217 | bool success; |
| 218 | bytes memory returnData; |
| 219 | |
| 220 | // 4-byte selector for `isBlacklisted(address)`, used by USDC. |
| 221 | (success, returnData) = token.staticcall(abi.encodeWithSelector(0xfe575a87, addr)); |
| 222 | vm.assume(!success || abi.decode(returnData, (bool)) == false); |
| 223 | |
| 224 | // 4-byte selector for `isBlackListed(address)`, used by USDT. |
| 225 | (success, returnData) = token.staticcall(abi.encodeWithSelector(0xe47d6060, addr)); |
| 226 | vm.assume(!success || abi.decode(returnData, (bool)) == false); |
| 227 | } |
| 228 | |
| 229 | // Checks that `addr` is not blacklisted by token contracts that have a blacklist. |
| 230 | // This is identical to `assumeNotBlacklisted(address,address)` but with a different name, for |
| 231 | // backwards compatibility, since this name was used in the original PR which already has |
| 232 | // a release. This function can be removed in a future release once we want a breaking change. |
| 233 | function assumeNoBlacklisted(address token, address addr) internal view virtual { |
| 234 | assumeNotBlacklisted(token, addr); |
| 235 | } |
| 236 | |
| 237 | function assumeAddressIsNot(address addr, AddressType addressType) internal virtual { |
| 238 | if (addressType == AddressType.Payable) { |
| 239 | assumeNotPayable(addr); |
| 240 | } else if (addressType == AddressType.NonPayable) { |
| 241 | assumePayable(addr); |
| 242 | } else if (addressType == AddressType.ZeroAddress) { |
| 243 | assumeNotZeroAddress(addr); |
| 244 | } else if (addressType == AddressType.Precompile) { |
| 245 | assumeNotPrecompile(addr); |
| 246 | } else if (addressType == AddressType.ForgeAddress) { |
| 247 | assumeNotForgeAddress(addr); |
| 248 | } |
| 249 | } |
| 250 | |
| 251 | function assumeAddressIsNot(address addr, AddressType addressType1, AddressType addressType2) internal virtual { |
| 252 | assumeAddressIsNot(addr, addressType1); |
| 253 | assumeAddressIsNot(addr, addressType2); |
| 254 | } |
| 255 | |
| 256 | function assumeAddressIsNot( |
| 257 | address addr, |
| 258 | AddressType addressType1, |
| 259 | AddressType addressType2, |
| 260 | AddressType addressType3 |
| 261 | ) internal virtual { |
| 262 | assumeAddressIsNot(addr, addressType1); |
| 263 | assumeAddressIsNot(addr, addressType2); |
| 264 | assumeAddressIsNot(addr, addressType3); |
| 265 | } |
| 266 | |
| 267 | function assumeAddressIsNot( |
| 268 | address addr, |
| 269 | AddressType addressType1, |
| 270 | AddressType addressType2, |
| 271 | AddressType addressType3, |
| 272 | AddressType addressType4 |
| 273 | ) internal virtual { |
| 274 | assumeAddressIsNot(addr, addressType1); |
| 275 | assumeAddressIsNot(addr, addressType2); |
| 276 | assumeAddressIsNot(addr, addressType3); |
| 277 | assumeAddressIsNot(addr, addressType4); |
| 278 | } |
| 279 | |
| 280 | // This function checks whether an address, `addr`, is payable. It works by sending 1 wei to |
| 281 | // `addr` and checking the `success` return value. |
| 282 | // NOTE: This function may result in state changes depending on the fallback/receive logic |
| 283 | // implemented by `addr`, which should be taken into account when this function is used. |
| 284 | function _isPayable(address addr) private returns (bool) { |
| 285 | require( |
| 286 | addr.balance < UINT256_MAX, |
| 287 | "StdCheats _isPayable(address): Balance equals max uint256, so it cannot receive any more funds" |
| 288 | ); |
| 289 | uint256 origBalanceTest = address(this).balance; |
| 290 | uint256 origBalanceAddr = address(addr).balance; |
| 291 | |
| 292 | vm.deal(address(this), 1); |
| 293 | (bool success,) = payable(addr).call{value: 1}(""); |
| 294 | |
| 295 | // reset balances |
| 296 | vm.deal(address(this), origBalanceTest); |
| 297 | vm.deal(addr, origBalanceAddr); |
| 298 | |
| 299 | return success; |
| 300 | } |
| 301 | |
| 302 | // NOTE: This function may result in state changes depending on the fallback/receive logic |
| 303 | // implemented by `addr`, which should be taken into account when this function is used. See the |
| 304 | // `_isPayable` method for more information. |
| 305 | function assumePayable(address addr) internal virtual { |
| 306 | vm.assume(_isPayable(addr)); |
| 307 | } |
| 308 | |
| 309 | function assumeNotPayable(address addr) internal virtual { |
| 310 | vm.assume(!_isPayable(addr)); |
| 311 | } |
| 312 | |
| 313 | function assumeNotZeroAddress(address addr) internal pure virtual { |
| 314 | vm.assume(addr != address(0)); |
| 315 | } |
| 316 | |
| 317 | function assumeNotPrecompile(address addr) internal pure virtual { |
| 318 | assumeNotPrecompile(addr, _pureChainId()); |
| 319 | } |
| 320 | |
| 321 | function assumeNotPrecompile(address addr, uint256 chainId) internal pure virtual { |
| 322 | // Note: For some chains like Optimism these are technically predeploys (i.e. bytecode placed at a specific |
| 323 | // address), but the same rationale for excluding them applies so we include those too. |
| 324 | |
| 325 | // These are reserved by Ethereum and may be on all EVM-compatible chains. |
| 326 | vm.assume(addr < address(0x1) || addr > address(0xff)); |
| 327 | |
| 328 | // forgefmt: disable-start |
| 329 | if (chainId == 10 || chainId == 420 || chainId == 11155420) { |
| 330 | // https://github.com/ethereum-optimism/optimism/blob/eaa371a0184b56b7ca6d9eb9cb0a2b78b2ccd864/op-bindings/predeploys/addresses.go#L6-L21 |
| 331 | vm.assume(addr < address(0x4200000000000000000000000000000000000000) || addr > address(0x4200000000000000000000000000000000000800)); |
| 332 | } else if (chainId == 42161 || chainId == 421613) { |
| 333 | // https://developer.arbitrum.io/useful-addresses#arbitrum-precompiles-l2-same-on-all-arb-chains |
| 334 | vm.assume(addr < address(0x0000000000000000000000000000000000000064) || addr > address(0x0000000000000000000000000000000000000068)); |
| 335 | } else if (chainId == 43114 || chainId == 43113) { |
| 336 | // https://github.com/ava-labs/subnet-evm/blob/47c03fd007ecaa6de2c52ea081596e0a88401f58/precompile/params.go#L18-L59 |
| 337 | vm.assume(addr < address(0x0100000000000000000000000000000000000000) || addr > address(0x01000000000000000000000000000000000000ff)); |
| 338 | vm.assume(addr < address(0x0200000000000000000000000000000000000000) || addr > address(0x02000000000000000000000000000000000000FF)); |
| 339 | vm.assume(addr < address(0x0300000000000000000000000000000000000000) || addr > address(0x03000000000000000000000000000000000000Ff)); |
| 340 | } |
| 341 | // forgefmt: disable-end |
| 342 | } |
| 343 | |
| 344 | function assumeNotForgeAddress(address addr) internal pure virtual { |
| 345 | // vm, console, and Create2Deployer addresses |
| 346 | vm.assume( |
| 347 | addr != address(vm) && addr != 0x000000000000000000636F6e736F6c652e6c6f67 |
| 348 | && addr != 0x4e59b44847b379578588920cA78FbF26c0B4956C |
| 349 | ); |
| 350 | } |
| 351 | |
| 352 | function assumeUnusedAddress(address addr) internal view virtual { |
| 353 | uint256 size; |
| 354 | assembly { |
| 355 | size := extcodesize(addr) |
| 356 | } |
| 357 | vm.assume(size == 0); |
| 358 | |
| 359 | assumeNotPrecompile(addr); |
| 360 | assumeNotZeroAddress(addr); |
| 361 | assumeNotForgeAddress(addr); |
| 362 | } |
| 363 | |
| 364 | function readEIP1559ScriptArtifact(string memory path) |
| 365 | internal |
| 366 | view |
| 367 | virtual |
| 368 | returns (EIP1559ScriptArtifact memory) |
| 369 | { |
| 370 | string memory data = vm.readFile(path); |
| 371 | bytes memory parsedData = vm.parseJson(data); |
| 372 | RawEIP1559ScriptArtifact memory rawArtifact = abi.decode(parsedData, (RawEIP1559ScriptArtifact)); |
| 373 | EIP1559ScriptArtifact memory artifact; |
| 374 | artifact.libraries = rawArtifact.libraries; |
| 375 | artifact.path = rawArtifact.path; |
| 376 | artifact.timestamp = rawArtifact.timestamp; |
| 377 | artifact.pending = rawArtifact.pending; |
| 378 | artifact.txReturns = rawArtifact.txReturns; |
| 379 | artifact.receipts = rawToConvertedReceipts(rawArtifact.receipts); |
| 380 | artifact.transactions = rawToConvertedEIPTx1559s(rawArtifact.transactions); |
| 381 | return artifact; |
| 382 | } |
| 383 | |
| 384 | function rawToConvertedEIPTx1559s(RawTx1559[] memory rawTxs) internal pure virtual returns (Tx1559[] memory) { |
| 385 | Tx1559[] memory txs = new Tx1559[](rawTxs.length); |
| 386 | for (uint256 i; i < rawTxs.length; i++) { |
| 387 | txs[i] = rawToConvertedEIPTx1559(rawTxs[i]); |
| 388 | } |
| 389 | return txs; |
| 390 | } |
| 391 | |
| 392 | function rawToConvertedEIPTx1559(RawTx1559 memory rawTx) internal pure virtual returns (Tx1559 memory) { |
| 393 | Tx1559 memory transaction; |
| 394 | transaction.arguments = rawTx.arguments; |
| 395 | transaction.contractName = rawTx.contractName; |
| 396 | transaction.functionSig = rawTx.functionSig; |
| 397 | transaction.hash = rawTx.hash; |
| 398 | transaction.txDetail = rawToConvertedEIP1559Detail(rawTx.txDetail); |
| 399 | transaction.opcode = rawTx.opcode; |
| 400 | return transaction; |
| 401 | } |
| 402 | |
| 403 | function rawToConvertedEIP1559Detail(RawTx1559Detail memory rawDetail) |
| 404 | internal |
| 405 | pure |
| 406 | virtual |
| 407 | returns (Tx1559Detail memory) |
| 408 | { |
| 409 | Tx1559Detail memory txDetail; |
| 410 | txDetail.data = rawDetail.data; |
| 411 | txDetail.from = rawDetail.from; |
| 412 | txDetail.to = rawDetail.to; |
| 413 | txDetail.nonce = _bytesToUint(rawDetail.nonce); |
| 414 | txDetail.txType = _bytesToUint(rawDetail.txType); |
| 415 | txDetail.value = _bytesToUint(rawDetail.value); |
| 416 | txDetail.gas = _bytesToUint(rawDetail.gas); |
| 417 | txDetail.accessList = rawDetail.accessList; |
| 418 | return txDetail; |
| 419 | } |
| 420 | |
| 421 | function readTx1559s(string memory path) internal view virtual returns (Tx1559[] memory) { |
| 422 | string memory deployData = vm.readFile(path); |
| 423 | bytes memory parsedDeployData = vm.parseJson(deployData, ".transactions"); |
| 424 | RawTx1559[] memory rawTxs = abi.decode(parsedDeployData, (RawTx1559[])); |
| 425 | return rawToConvertedEIPTx1559s(rawTxs); |
| 426 | } |
| 427 | |
| 428 | function readTx1559(string memory path, uint256 index) internal view virtual returns (Tx1559 memory) { |
| 429 | string memory deployData = vm.readFile(path); |
| 430 | string memory key = string(abi.encodePacked(".transactions[", vm.toString(index), "]")); |
| 431 | bytes memory parsedDeployData = vm.parseJson(deployData, key); |
| 432 | RawTx1559 memory rawTx = abi.decode(parsedDeployData, (RawTx1559)); |
| 433 | return rawToConvertedEIPTx1559(rawTx); |
| 434 | } |
| 435 | |
| 436 | // Analogous to readTransactions, but for receipts. |
| 437 | function readReceipts(string memory path) internal view virtual returns (Receipt[] memory) { |
| 438 | string memory deployData = vm.readFile(path); |
| 439 | bytes memory parsedDeployData = vm.parseJson(deployData, ".receipts"); |
| 440 | RawReceipt[] memory rawReceipts = abi.decode(parsedDeployData, (RawReceipt[])); |
| 441 | return rawToConvertedReceipts(rawReceipts); |
| 442 | } |
| 443 | |
| 444 | function readReceipt(string memory path, uint256 index) internal view virtual returns (Receipt memory) { |
| 445 | string memory deployData = vm.readFile(path); |
| 446 | string memory key = string(abi.encodePacked(".receipts[", vm.toString(index), "]")); |
| 447 | bytes memory parsedDeployData = vm.parseJson(deployData, key); |
| 448 | RawReceipt memory rawReceipt = abi.decode(parsedDeployData, (RawReceipt)); |
| 449 | return rawToConvertedReceipt(rawReceipt); |
| 450 | } |
| 451 | |
| 452 | function rawToConvertedReceipts(RawReceipt[] memory rawReceipts) internal pure virtual returns (Receipt[] memory) { |
| 453 | Receipt[] memory receipts = new Receipt[](rawReceipts.length); |
| 454 | for (uint256 i; i < rawReceipts.length; i++) { |
| 455 | receipts[i] = rawToConvertedReceipt(rawReceipts[i]); |
| 456 | } |
| 457 | return receipts; |
| 458 | } |
| 459 | |
| 460 | function rawToConvertedReceipt(RawReceipt memory rawReceipt) internal pure virtual returns (Receipt memory) { |
| 461 | Receipt memory receipt; |
| 462 | receipt.blockHash = rawReceipt.blockHash; |
| 463 | receipt.to = rawReceipt.to; |
| 464 | receipt.from = rawReceipt.from; |
| 465 | receipt.contractAddress = rawReceipt.contractAddress; |
| 466 | receipt.effectiveGasPrice = _bytesToUint(rawReceipt.effectiveGasPrice); |
| 467 | receipt.cumulativeGasUsed = _bytesToUint(rawReceipt.cumulativeGasUsed); |
| 468 | receipt.gasUsed = _bytesToUint(rawReceipt.gasUsed); |
| 469 | receipt.status = _bytesToUint(rawReceipt.status); |
| 470 | receipt.transactionIndex = _bytesToUint(rawReceipt.transactionIndex); |
| 471 | receipt.blockNumber = _bytesToUint(rawReceipt.blockNumber); |
| 472 | receipt.logs = rawToConvertedReceiptLogs(rawReceipt.logs); |
| 473 | receipt.logsBloom = rawReceipt.logsBloom; |
| 474 | receipt.transactionHash = rawReceipt.transactionHash; |
| 475 | return receipt; |
| 476 | } |
| 477 | |
| 478 | function rawToConvertedReceiptLogs(RawReceiptLog[] memory rawLogs) |
| 479 | internal |
| 480 | pure |
| 481 | virtual |
| 482 | returns (ReceiptLog[] memory) |
| 483 | { |
| 484 | ReceiptLog[] memory logs = new ReceiptLog[](rawLogs.length); |
| 485 | for (uint256 i; i < rawLogs.length; i++) { |
| 486 | logs[i].logAddress = rawLogs[i].logAddress; |
| 487 | logs[i].blockHash = rawLogs[i].blockHash; |
| 488 | logs[i].blockNumber = _bytesToUint(rawLogs[i].blockNumber); |
| 489 | logs[i].data = rawLogs[i].data; |
| 490 | logs[i].logIndex = _bytesToUint(rawLogs[i].logIndex); |
| 491 | logs[i].topics = rawLogs[i].topics; |
| 492 | logs[i].transactionIndex = _bytesToUint(rawLogs[i].transactionIndex); |
| 493 | logs[i].transactionLogIndex = _bytesToUint(rawLogs[i].transactionLogIndex); |
| 494 | logs[i].removed = rawLogs[i].removed; |
| 495 | } |
| 496 | return logs; |
| 497 | } |
| 498 | |
| 499 | // Deploy a contract by fetching the contract bytecode from |
| 500 | // the artifacts directory |
| 501 | // e.g. `deployCode(code, abi.encode(arg1,arg2,arg3))` |
| 502 | function deployCode(string memory what, bytes memory args) internal virtual returns (address addr) { |
| 503 | bytes memory bytecode = abi.encodePacked(vm.getCode(what), args); |
| 504 | /// @solidity memory-safe-assembly |
| 505 | assembly { |
| 506 | addr := create(0, add(bytecode, 0x20), mload(bytecode)) |
| 507 | } |
| 508 | |
| 509 | require(addr != address(0), "StdCheats deployCode(string,bytes): Deployment failed."); |
| 510 | } |
| 511 | |
| 512 | function deployCode(string memory what) internal virtual returns (address addr) { |
| 513 | bytes memory bytecode = vm.getCode(what); |
| 514 | /// @solidity memory-safe-assembly |
| 515 | assembly { |
| 516 | addr := create(0, add(bytecode, 0x20), mload(bytecode)) |
| 517 | } |
| 518 | |
| 519 | require(addr != address(0), "StdCheats deployCode(string): Deployment failed."); |
| 520 | } |
| 521 | |
| 522 | /// @dev deploy contract with value on construction |
| 523 | function deployCode(string memory what, bytes memory args, uint256 val) internal virtual returns (address addr) { |
| 524 | bytes memory bytecode = abi.encodePacked(vm.getCode(what), args); |
| 525 | /// @solidity memory-safe-assembly |
| 526 | assembly { |
| 527 | addr := create(val, add(bytecode, 0x20), mload(bytecode)) |
| 528 | } |
| 529 | |
| 530 | require(addr != address(0), "StdCheats deployCode(string,bytes,uint256): Deployment failed."); |
| 531 | } |
| 532 | |
| 533 | function deployCode(string memory what, uint256 val) internal virtual returns (address addr) { |
| 534 | bytes memory bytecode = vm.getCode(what); |
| 535 | /// @solidity memory-safe-assembly |
| 536 | assembly { |
| 537 | addr := create(val, add(bytecode, 0x20), mload(bytecode)) |
| 538 | } |
| 539 | |
| 540 | require(addr != address(0), "StdCheats deployCode(string,uint256): Deployment failed."); |
| 541 | } |
| 542 | |
| 543 | // creates a labeled address and the corresponding private key |
| 544 | function makeAddrAndKey(string memory name) internal virtual returns (address addr, uint256 privateKey) { |
| 545 | privateKey = uint256(keccak256(abi.encodePacked(name))); |
| 546 | addr = vm.addr(privateKey); |
| 547 | vm.label(addr, name); |
| 548 | } |
| 549 | |
| 550 | // creates a labeled address |
| 551 | function makeAddr(string memory name) internal virtual returns (address addr) { |
| 552 | (addr,) = makeAddrAndKey(name); |
| 553 | } |
| 554 | |
| 555 | // Destroys an account immediately, sending the balance to beneficiary. |
| 556 | // Destroying means: balance will be zero, code will be empty, and nonce will be 0 |
| 557 | // This is similar to selfdestruct but not identical: selfdestruct destroys code and nonce |
| 558 | // only after tx ends, this will run immediately. |
| 559 | function destroyAccount(address who, address beneficiary) internal virtual { |
| 560 | uint256 currBalance = who.balance; |
| 561 | vm.etch(who, abi.encode()); |
| 562 | vm.deal(who, 0); |
| 563 | vm.resetNonce(who); |
| 564 | |
| 565 | uint256 beneficiaryBalance = beneficiary.balance; |
| 566 | vm.deal(beneficiary, currBalance + beneficiaryBalance); |
| 567 | } |
| 568 | |
| 569 | // creates a struct containing both a labeled address and the corresponding private key |
| 570 | function makeAccount(string memory name) internal virtual returns (Account memory account) { |
| 571 | (account.addr, account.key) = makeAddrAndKey(name); |
| 572 | } |
| 573 | |
| 574 | function deriveRememberKey(string memory mnemonic, uint32 index) |
| 575 | internal |
| 576 | virtual |
| 577 | returns (address who, uint256 privateKey) |
| 578 | { |
| 579 | privateKey = vm.deriveKey(mnemonic, index); |
| 580 | who = vm.rememberKey(privateKey); |
| 581 | } |
| 582 | |
| 583 | function _bytesToUint(bytes memory b) private pure returns (uint256) { |
| 584 | require(b.length <= 32, "StdCheats _bytesToUint(bytes): Bytes length exceeds 32."); |
| 585 | return abi.decode(abi.encodePacked(new bytes(32 - b.length), b), (uint256)); |
| 586 | } |
| 587 | |
| 588 | function isFork() internal view virtual returns (bool status) { |
| 589 | try vm.activeFork() { |
| 590 | status = true; |
| 591 | } catch (bytes memory) {} |
| 592 | } |
| 593 | |
| 594 | modifier skipWhenForking() { |
| 595 | if (!isFork()) { |
| 596 | _; |
| 597 | } |
| 598 | } |
| 599 | |
| 600 | modifier skipWhenNotForking() { |
| 601 | if (isFork()) { |
| 602 | _; |
| 603 | } |
| 604 | } |
| 605 | |
| 606 | modifier noGasMetering() { |
| 607 | vm.pauseGasMetering(); |
| 608 | // To prevent turning gas monitoring back on with nested functions that use this modifier, |
| 609 | // we check if gasMetering started in the off position. If it did, we don't want to turn |
| 610 | // it back on until we exit the top level function that used the modifier |
| 611 | // |
| 612 | // i.e. funcA() noGasMetering { funcB() }, where funcB has noGasMetering as well. |
| 613 | // funcA will have `gasStartedOff` as false, funcB will have it as true, |
| 614 | // so we only turn metering back on at the end of the funcA |
| 615 | bool gasStartedOff = gasMeteringOff; |
| 616 | gasMeteringOff = true; |
| 617 | |
| 618 | _; |
| 619 | |
| 620 | // if gas metering was on when this modifier was called, turn it back on at the end |
| 621 | if (!gasStartedOff) { |
| 622 | gasMeteringOff = false; |
| 623 | vm.resumeGasMetering(); |
| 624 | } |
| 625 | } |
| 626 | |
| 627 | // We use this complex approach of `_viewChainId` and `_pureChainId` to ensure there are no |
| 628 | // compiler warnings when accessing chain ID in any solidity version supported by forge-std. We |
| 629 | // can't simply access the chain ID in a normal view or pure function because the solc View Pure |
| 630 | // Checker changed `chainid` from pure to view in 0.8.0. |
| 631 | function _viewChainId() private view returns (uint256 chainId) { |
| 632 | // Assembly required since `block.chainid` was introduced in 0.8.0. |
| 633 | assembly { |
| 634 | chainId := chainid() |
| 635 | } |
| 636 | |
| 637 | address(this); // Silence warnings in older Solc versions. |
| 638 | } |
| 639 | |
| 640 | function _pureChainId() private pure returns (uint256 chainId) { |
| 641 | function() internal view returns (uint256) fnIn = _viewChainId; |
| 642 | function() internal pure returns (uint256) pureChainId; |
| 643 | assembly { |
| 644 | pureChainId := fnIn |
| 645 | } |
| 646 | chainId = pureChainId(); |
| 647 | } |
| 648 | } |
| 649 | |
| 650 | // Wrappers around cheatcodes to avoid footguns |
| 651 | abstract contract StdCheats is StdCheatsSafe { |
| 652 | using stdStorage for StdStorage; |
| 653 | |
| 654 | StdStorage private stdstore; |
| 655 | Vm private constant vm = Vm(address(uint160(uint256(keccak256("hevm cheat code"))))); |
| 656 | address private constant CONSOLE2_ADDRESS = 0x000000000000000000636F6e736F6c652e6c6f67; |
| 657 | |
| 658 | // Skip forward or rewind time by the specified number of seconds |
| 659 | function skip(uint256 time) internal virtual { |
| 660 | vm.warp(vm.getBlockTimestamp() + time); |
| 661 | } |
| 662 | |
| 663 | function rewind(uint256 time) internal virtual { |
| 664 | vm.warp(vm.getBlockTimestamp() - time); |
| 665 | } |
| 666 | |
| 667 | // Setup a prank from an address that has some ether |
| 668 | function hoax(address msgSender) internal virtual { |
| 669 | vm.deal(msgSender, 1 << 128); |
| 670 | vm.prank(msgSender); |
| 671 | } |
| 672 | |
| 673 | function hoax(address msgSender, uint256 give) internal virtual { |
| 674 | vm.deal(msgSender, give); |
| 675 | vm.prank(msgSender); |
| 676 | } |
| 677 | |
| 678 | function hoax(address msgSender, address origin) internal virtual { |
| 679 | vm.deal(msgSender, 1 << 128); |
| 680 | vm.prank(msgSender, origin); |
| 681 | } |
| 682 | |
| 683 | function hoax(address msgSender, address origin, uint256 give) internal virtual { |
| 684 | vm.deal(msgSender, give); |
| 685 | vm.prank(msgSender, origin); |
| 686 | } |
| 687 | |
| 688 | // Start perpetual prank from an address that has some ether |
| 689 | function startHoax(address msgSender) internal virtual { |
| 690 | vm.deal(msgSender, 1 << 128); |
| 691 | vm.startPrank(msgSender); |
| 692 | } |
| 693 | |
| 694 | function startHoax(address msgSender, uint256 give) internal virtual { |
| 695 | vm.deal(msgSender, give); |
| 696 | vm.startPrank(msgSender); |
| 697 | } |
| 698 | |
| 699 | // Start perpetual prank from an address that has some ether |
| 700 | // tx.origin is set to the origin parameter |
| 701 | function startHoax(address msgSender, address origin) internal virtual { |
| 702 | vm.deal(msgSender, 1 << 128); |
| 703 | vm.startPrank(msgSender, origin); |
| 704 | } |
| 705 | |
| 706 | function startHoax(address msgSender, address origin, uint256 give) internal virtual { |
| 707 | vm.deal(msgSender, give); |
| 708 | vm.startPrank(msgSender, origin); |
| 709 | } |
| 710 | |
| 711 | function changePrank(address msgSender) internal virtual { |
| 712 | console2_log_StdCheats("changePrank is deprecated. Please use vm.startPrank instead."); |
| 713 | vm.stopPrank(); |
| 714 | vm.startPrank(msgSender); |
| 715 | } |
| 716 | |
| 717 | function changePrank(address msgSender, address txOrigin) internal virtual { |
| 718 | console2_log_StdCheats("changePrank is deprecated. Please use vm.startPrank instead."); |
| 719 | vm.stopPrank(); |
| 720 | vm.startPrank(msgSender, txOrigin); |
| 721 | } |
| 722 | |
| 723 | // The same as Vm's `deal` |
| 724 | // Use the alternative signature for ERC20 tokens |
| 725 | function deal(address to, uint256 give) internal virtual { |
| 726 | vm.deal(to, give); |
| 727 | } |
| 728 | |
| 729 | // Set the balance of an account for any ERC20 token |
| 730 | // Use the alternative signature to update `totalSupply` |
| 731 | function deal(address token, address to, uint256 give) internal virtual { |
| 732 | deal(token, to, give, false); |
| 733 | } |
| 734 | |
| 735 | // Set the balance of an account for any ERC1155 token |
| 736 | // Use the alternative signature to update `totalSupply` |
| 737 | function dealERC1155(address token, address to, uint256 id, uint256 give) internal virtual { |
| 738 | dealERC1155(token, to, id, give, false); |
| 739 | } |
| 740 | |
| 741 | function deal(address token, address to, uint256 give, bool adjust) internal virtual { |
| 742 | // get current balance |
| 743 | (, bytes memory balData) = token.staticcall(abi.encodeWithSelector(0x70a08231, to)); |
| 744 | uint256 prevBal = abi.decode(balData, (uint256)); |
| 745 | |
| 746 | // update balance |
| 747 | stdstore.target(token).sig(0x70a08231).with_key(to).checked_write(give); |
| 748 | |
| 749 | // update total supply |
| 750 | if (adjust) { |
| 751 | (, bytes memory totSupData) = token.staticcall(abi.encodeWithSelector(0x18160ddd)); |
| 752 | uint256 totSup = abi.decode(totSupData, (uint256)); |
| 753 | if (give < prevBal) { |
| 754 | totSup -= (prevBal - give); |
| 755 | } else { |
| 756 | totSup += (give - prevBal); |
| 757 | } |
| 758 | stdstore.target(token).sig(0x18160ddd).checked_write(totSup); |
| 759 | } |
| 760 | } |
| 761 | |
| 762 | function dealERC1155(address token, address to, uint256 id, uint256 give, bool adjust) internal virtual { |
| 763 | // get current balance |
| 764 | (, bytes memory balData) = token.staticcall(abi.encodeWithSelector(0x00fdd58e, to, id)); |
| 765 | uint256 prevBal = abi.decode(balData, (uint256)); |
| 766 | |
| 767 | // update balance |
| 768 | stdstore.target(token).sig(0x00fdd58e).with_key(to).with_key(id).checked_write(give); |
| 769 | |
| 770 | // update total supply |
| 771 | if (adjust) { |
| 772 | (, bytes memory totSupData) = token.staticcall(abi.encodeWithSelector(0xbd85b039, id)); |
| 773 | require( |
| 774 | totSupData.length != 0, |
| 775 | "StdCheats deal(address,address,uint,uint,bool): target contract is not ERC1155Supply." |
| 776 | ); |
| 777 | uint256 totSup = abi.decode(totSupData, (uint256)); |
| 778 | if (give < prevBal) { |
| 779 | totSup -= (prevBal - give); |
| 780 | } else { |
| 781 | totSup += (give - prevBal); |
| 782 | } |
| 783 | stdstore.target(token).sig(0xbd85b039).with_key(id).checked_write(totSup); |
| 784 | } |
| 785 | } |
| 786 | |
| 787 | function dealERC721(address token, address to, uint256 id) internal virtual { |
| 788 | // check if token id is already minted and the actual owner. |
| 789 | (bool successMinted, bytes memory ownerData) = token.staticcall(abi.encodeWithSelector(0x6352211e, id)); |
| 790 | require(successMinted, "StdCheats deal(address,address,uint,bool): id not minted."); |
| 791 | |
| 792 | // get owner current balance |
| 793 | (, bytes memory fromBalData) = |
| 794 | token.staticcall(abi.encodeWithSelector(0x70a08231, abi.decode(ownerData, (address)))); |
| 795 | uint256 fromPrevBal = abi.decode(fromBalData, (uint256)); |
| 796 | |
| 797 | // get new user current balance |
| 798 | (, bytes memory toBalData) = token.staticcall(abi.encodeWithSelector(0x70a08231, to)); |
| 799 | uint256 toPrevBal = abi.decode(toBalData, (uint256)); |
| 800 | |
| 801 | // update balances |
| 802 | stdstore.target(token).sig(0x70a08231).with_key(abi.decode(ownerData, (address))).checked_write(--fromPrevBal); |
| 803 | stdstore.target(token).sig(0x70a08231).with_key(to).checked_write(++toPrevBal); |
| 804 | |
| 805 | // update owner |
| 806 | stdstore.target(token).sig(0x6352211e).with_key(id).checked_write(to); |
| 807 | } |
| 808 | |
| 809 | function deployCodeTo(string memory what, address where) internal virtual { |
| 810 | deployCodeTo(what, "", 0, where); |
| 811 | } |
| 812 | |
| 813 | function deployCodeTo(string memory what, bytes memory args, address where) internal virtual { |
| 814 | deployCodeTo(what, args, 0, where); |
| 815 | } |
| 816 | |
| 817 | function deployCodeTo(string memory what, bytes memory args, uint256 value, address where) internal virtual { |
| 818 | bytes memory creationCode = vm.getCode(what); |
| 819 | vm.etch(where, abi.encodePacked(creationCode, args)); |
| 820 | (bool success, bytes memory runtimeBytecode) = where.call{value: value}(""); |
| 821 | require(success, "StdCheats deployCodeTo(string,bytes,uint256,address): Failed to create runtime bytecode."); |
| 822 | vm.etch(where, runtimeBytecode); |
| 823 | } |
| 824 | |
| 825 | // Used to prevent the compilation of console, which shortens the compilation time when console is not used elsewhere. |
| 826 | function console2_log_StdCheats(string memory p0) private view { |
| 827 | (bool status,) = address(CONSOLE2_ADDRESS).staticcall(abi.encodeWithSignature("log(string)", p0)); |
| 828 | status; |
| 829 | } |
| 830 | } |
| 831 |
0.0%
lib/forge-std/src/StdConstants.sol
Lines covered: 0 / 1 (0.0%)
| 1 | // SPDX-License-Identifier: MIT |
| 2 | pragma solidity >=0.6.2 <0.9.0; |
| 3 | |
| 4 | import {IMulticall3} from "./interfaces/IMulticall3.sol"; |
| 5 | import {Vm} from "./Vm.sol"; |
| 6 | |
| 7 | library StdConstants { |
| 8 | /// @dev Cheat code address. |
| 9 | /// Calculated as `address(uint160(uint256(keccak256("hevm cheat code"))))`. |
| 10 | Vm internal constant VM = Vm(0x7109709ECfa91a80626fF3989D68f67F5b1DD12D); |
| 11 | /// @dev console.sol and console2.sol work by executing a staticcall to this address. |
| 12 | /// Calculated as `address(uint160(uint88(bytes11("console.log"))))`. |
| 13 | address internal constant CONSOLE = 0x000000000000000000636F6e736F6c652e6c6f67; |
| 14 | /// @dev Used when deploying with create2. |
| 15 | /// Taken from https://github.com/Arachnid/deterministic-deployment-proxy. |
| 16 | address internal constant CREATE2_FACTORY = 0x4e59b44847b379578588920cA78FbF26c0B4956C; |
| 17 | /// @dev The default address for tx.origin and msg.sender. |
| 18 | /// Calculated as `address(uint160(uint256(keccak256("foundry default caller"))))`. |
| 19 | address internal constant DEFAULT_SENDER = 0x1804c8AB1F12E6bbf3894d4083f33e07309d1f38; |
| 20 | /// @dev The address of the first contract `CREATE`d by a running test contract. |
| 21 | /// When running tests, each test contract is `CREATE`d by `DEFAULT_SENDER` with nonce 1. |
| 22 | /// Calculated as `VM.computeCreateAddress(VM.computeCreateAddress(DEFAULT_SENDER, 1), 1)`. |
| 23 | address internal constant DEFAULT_TEST_CONTRACT = 0x5615dEB798BB3E4dFa0139dFa1b3D433Cc23b72f; |
| 24 | /// @dev Deterministic deployment address of the Multicall3 contract. |
| 25 | /// Taken from https://www.multicall3.com. |
| 26 | IMulticall3 internal constant MULTICALL3_ADDRESS = IMulticall3(0xcA11bde05977b3631167028862bE2a173976CA11); |
| 27 | /// @dev The order of the secp256k1 curve. |
| 28 | uint256 internal constant SECP256K1_ORDER = |
| 29 | 115792089237316195423570985008687907852837564279074904382605163141518161494337; |
| 30 | } |
| 31 |
0.0%
lib/forge-std/src/StdError.sol
Lines covered: 0 / 10 (0.0%)
| 1 | // SPDX-License-Identifier: MIT |
| 2 | // Panics work for versions >=0.8.0, but we lowered the pragma to make this compatible with Test |
| 3 | pragma solidity >=0.6.2 <0.9.0; |
| 4 | |
| 5 | library stdError { |
| 6 | bytes public constant assertionError = abi.encodeWithSignature("Panic(uint256)", 0x01); |
| 7 | bytes public constant arithmeticError = abi.encodeWithSignature("Panic(uint256)", 0x11); |
| 8 | bytes public constant divisionError = abi.encodeWithSignature("Panic(uint256)", 0x12); |
| 9 | bytes public constant enumConversionError = abi.encodeWithSignature("Panic(uint256)", 0x21); |
| 10 | bytes public constant encodeStorageError = abi.encodeWithSignature("Panic(uint256)", 0x22); |
| 11 | bytes public constant popError = abi.encodeWithSignature("Panic(uint256)", 0x31); |
| 12 | bytes public constant indexOOBError = abi.encodeWithSignature("Panic(uint256)", 0x32); |
| 13 | bytes public constant memOverflowError = abi.encodeWithSignature("Panic(uint256)", 0x41); |
| 14 | bytes public constant zeroVarError = abi.encodeWithSignature("Panic(uint256)", 0x51); |
| 15 | } |
| 16 |
100.0%
lib/forge-std/src/StdInvariant.sol
Lines covered: 12 / 12 (100.0%)
| 1 | // SPDX-License-Identifier: MIT |
| 2 | pragma solidity >=0.6.2 <0.9.0; |
| 3 | |
| 4 | pragma experimental ABIEncoderV2; |
| 5 | |
| 6 | abstract contract StdInvariant { |
| 7 | struct FuzzSelector { |
| 8 | address addr; |
| 9 | bytes4[] selectors; |
| 10 | } |
| 11 | |
| 12 | struct FuzzArtifactSelector { |
| 13 | string artifact; |
| 14 | bytes4[] selectors; |
| 15 | } |
| 16 | |
| 17 | struct FuzzInterface { |
| 18 | address addr; |
| 19 | string[] artifacts; |
| 20 | } |
| 21 | |
| 22 | address[] private _excludedContracts; |
| 23 | address[] private _excludedSenders; |
| 24 | address[] private _targetedContracts; |
| 25 | address[] private _targetedSenders; |
| 26 | |
| 27 | string[] private _excludedArtifacts; |
| 28 | string[] private _targetedArtifacts; |
| 29 | |
| 30 | FuzzArtifactSelector[] private _targetedArtifactSelectors; |
| 31 | |
| 32 | FuzzSelector[] private _excludedSelectors; |
| 33 | FuzzSelector[] private _targetedSelectors; |
| 34 | |
| 35 | FuzzInterface[] private _targetedInterfaces; |
| 36 | |
| 37 | // Functions for users: |
| 38 | // These are intended to be called in tests. |
| 39 | |
| 40 | function excludeContract(address newExcludedContract_) internal { |
| 41 | _excludedContracts.push(newExcludedContract_); |
| 42 | } |
| 43 | |
| 44 | function excludeSelector(FuzzSelector memory newExcludedSelector_) internal { |
| 45 | _excludedSelectors.push(newExcludedSelector_); |
| 46 | } |
| 47 | |
| 48 | function excludeSender(address newExcludedSender_) internal { |
| 49 | _excludedSenders.push(newExcludedSender_); |
| 50 | } |
| 51 | |
| 52 | function excludeArtifact(string memory newExcludedArtifact_) internal { |
| 53 | _excludedArtifacts.push(newExcludedArtifact_); |
| 54 | } |
| 55 | |
| 56 | function targetArtifact(string memory newTargetedArtifact_) internal { |
| 57 | _targetedArtifacts.push(newTargetedArtifact_); |
| 58 | } |
| 59 | |
| 60 | function targetArtifactSelector(FuzzArtifactSelector memory newTargetedArtifactSelector_) internal { |
| 61 | _targetedArtifactSelectors.push(newTargetedArtifactSelector_); |
| 62 | } |
| 63 | |
| 64 | function targetContract(address newTargetedContract_) internal { |
| 65 | _targetedContracts.push(newTargetedContract_); |
| 66 | } |
| 67 | |
| 68 | function targetSelector(FuzzSelector memory newTargetedSelector_) internal { |
| 69 | _targetedSelectors.push(newTargetedSelector_); |
| 70 | } |
| 71 | |
| 72 | function targetSender(address newTargetedSender_) internal { |
| 73 | _targetedSenders.push(newTargetedSender_); |
| 74 | } |
| 75 | |
| 76 | function targetInterface(FuzzInterface memory newTargetedInterface_) internal { |
| 77 | _targetedInterfaces.push(newTargetedInterface_); |
| 78 | } |
| 79 | |
| 80 | // Functions for forge: |
| 81 | // These are called by forge to run invariant tests and don't need to be called in tests. |
| 82 | |
| 83 | function excludeArtifacts() public view returns (string[] memory excludedArtifacts_) { |
| 84 | excludedArtifacts_ = _excludedArtifacts; |
| 85 | } |
| 86 | |
| 87 | function excludeContracts() public view returns (address[] memory excludedContracts_) { |
| 88 | excludedContracts_ = _excludedContracts; |
| 89 | } |
| 90 | |
| 91 | function excludeSelectors() public view returns (FuzzSelector[] memory excludedSelectors_) { |
| 92 | excludedSelectors_ = _excludedSelectors; |
| 93 | } |
| 94 | |
| 95 | function excludeSenders() public view returns (address[] memory excludedSenders_) { |
| 96 | excludedSenders_ = _excludedSenders; |
| 97 | } |
| 98 | |
| 99 | function targetArtifacts() public view returns (string[] memory targetedArtifacts_) { |
| 100 | targetedArtifacts_ = _targetedArtifacts; |
| 101 | } |
| 102 | |
| 103 | function targetArtifactSelectors() public view returns (FuzzArtifactSelector[] memory targetedArtifactSelectors_) { |
| 104 | targetedArtifactSelectors_ = _targetedArtifactSelectors; |
| 105 | } |
| 106 | |
| 107 | function targetContracts() public view returns (address[] memory targetedContracts_) { |
| 108 | targetedContracts_ = _targetedContracts; |
| 109 | } |
| 110 | |
| 111 | function targetSelectors() public view returns (FuzzSelector[] memory targetedSelectors_) { |
| 112 | targetedSelectors_ = _targetedSelectors; |
| 113 | } |
| 114 | |
| 115 | function targetSenders() public view returns (address[] memory targetedSenders_) { |
| 116 | targetedSenders_ = _targetedSenders; |
| 117 | } |
| 118 | |
| 119 | function targetInterfaces() public view returns (FuzzInterface[] memory targetedInterfaces_) { |
| 120 | targetedInterfaces_ = _targetedInterfaces; |
| 121 | } |
| 122 | } |
| 123 |
0.0%
lib/forge-std/src/StdJson.sol
Lines covered: 0 / 1 (0.0%)
| 1 | // SPDX-License-Identifier: MIT |
| 2 | pragma solidity >=0.6.0 <0.9.0; |
| 3 | |
| 4 | pragma experimental ABIEncoderV2; |
| 5 | |
| 6 | import {VmSafe} from "./Vm.sol"; |
| 7 | |
| 8 | // Helpers for parsing and writing JSON files |
| 9 | // To parse: |
| 10 | // ``` |
| 11 | // using stdJson for string; |
| 12 | // string memory json = vm.readFile("<some_path>"); |
| 13 | // json.readUint("<json_path>"); |
| 14 | // ``` |
| 15 | // To write: |
| 16 | // ``` |
| 17 | // using stdJson for string; |
| 18 | // string memory json = "json"; |
| 19 | // json.serialize("a", uint256(123)); |
| 20 | // string memory semiFinal = json.serialize("b", string("test")); |
| 21 | // string memory finalJson = json.serialize("c", semiFinal); |
| 22 | // finalJson.write("<some_path>"); |
| 23 | // ``` |
| 24 | |
| 25 | library stdJson { |
| 26 | VmSafe private constant vm = VmSafe(address(uint160(uint256(keccak256("hevm cheat code"))))); |
| 27 | |
| 28 | function keyExists(string memory json, string memory key) internal view returns (bool) { |
| 29 | return vm.keyExistsJson(json, key); |
| 30 | } |
| 31 | |
| 32 | function parseRaw(string memory json, string memory key) internal pure returns (bytes memory) { |
| 33 | return vm.parseJson(json, key); |
| 34 | } |
| 35 | |
| 36 | function readUint(string memory json, string memory key) internal pure returns (uint256) { |
| 37 | return vm.parseJsonUint(json, key); |
| 38 | } |
| 39 | |
| 40 | function readUintArray(string memory json, string memory key) internal pure returns (uint256[] memory) { |
| 41 | return vm.parseJsonUintArray(json, key); |
| 42 | } |
| 43 | |
| 44 | function readInt(string memory json, string memory key) internal pure returns (int256) { |
| 45 | return vm.parseJsonInt(json, key); |
| 46 | } |
| 47 | |
| 48 | function readIntArray(string memory json, string memory key) internal pure returns (int256[] memory) { |
| 49 | return vm.parseJsonIntArray(json, key); |
| 50 | } |
| 51 | |
| 52 | function readBytes32(string memory json, string memory key) internal pure returns (bytes32) { |
| 53 | return vm.parseJsonBytes32(json, key); |
| 54 | } |
| 55 | |
| 56 | function readBytes32Array(string memory json, string memory key) internal pure returns (bytes32[] memory) { |
| 57 | return vm.parseJsonBytes32Array(json, key); |
| 58 | } |
| 59 | |
| 60 | function readString(string memory json, string memory key) internal pure returns (string memory) { |
| 61 | return vm.parseJsonString(json, key); |
| 62 | } |
| 63 | |
| 64 | function readStringArray(string memory json, string memory key) internal pure returns (string[] memory) { |
| 65 | return vm.parseJsonStringArray(json, key); |
| 66 | } |
| 67 | |
| 68 | function readAddress(string memory json, string memory key) internal pure returns (address) { |
| 69 | return vm.parseJsonAddress(json, key); |
| 70 | } |
| 71 | |
| 72 | function readAddressArray(string memory json, string memory key) internal pure returns (address[] memory) { |
| 73 | return vm.parseJsonAddressArray(json, key); |
| 74 | } |
| 75 | |
| 76 | function readBool(string memory json, string memory key) internal pure returns (bool) { |
| 77 | return vm.parseJsonBool(json, key); |
| 78 | } |
| 79 | |
| 80 | function readBoolArray(string memory json, string memory key) internal pure returns (bool[] memory) { |
| 81 | return vm.parseJsonBoolArray(json, key); |
| 82 | } |
| 83 | |
| 84 | function readBytes(string memory json, string memory key) internal pure returns (bytes memory) { |
| 85 | return vm.parseJsonBytes(json, key); |
| 86 | } |
| 87 | |
| 88 | function readBytesArray(string memory json, string memory key) internal pure returns (bytes[] memory) { |
| 89 | return vm.parseJsonBytesArray(json, key); |
| 90 | } |
| 91 | |
| 92 | function readUintOr(string memory json, string memory key, uint256 defaultValue) internal view returns (uint256) { |
| 93 | return keyExists(json, key) ? readUint(json, key) : defaultValue; |
| 94 | } |
| 95 | |
| 96 | function readUintArrayOr(string memory json, string memory key, uint256[] memory defaultValue) |
| 97 | internal |
| 98 | view |
| 99 | returns (uint256[] memory) |
| 100 | { |
| 101 | return keyExists(json, key) ? readUintArray(json, key) : defaultValue; |
| 102 | } |
| 103 | |
| 104 | function readIntOr(string memory json, string memory key, int256 defaultValue) internal view returns (int256) { |
| 105 | return keyExists(json, key) ? readInt(json, key) : defaultValue; |
| 106 | } |
| 107 | |
| 108 | function readIntArrayOr(string memory json, string memory key, int256[] memory defaultValue) |
| 109 | internal |
| 110 | view |
| 111 | returns (int256[] memory) |
| 112 | { |
| 113 | return keyExists(json, key) ? readIntArray(json, key) : defaultValue; |
| 114 | } |
| 115 | |
| 116 | function readBytes32Or(string memory json, string memory key, bytes32 defaultValue) |
| 117 | internal |
| 118 | view |
| 119 | returns (bytes32) |
| 120 | { |
| 121 | return keyExists(json, key) ? readBytes32(json, key) : defaultValue; |
| 122 | } |
| 123 | |
| 124 | function readBytes32ArrayOr(string memory json, string memory key, bytes32[] memory defaultValue) |
| 125 | internal |
| 126 | view |
| 127 | returns (bytes32[] memory) |
| 128 | { |
| 129 | return keyExists(json, key) ? readBytes32Array(json, key) : defaultValue; |
| 130 | } |
| 131 | |
| 132 | function readStringOr(string memory json, string memory key, string memory defaultValue) |
| 133 | internal |
| 134 | view |
| 135 | returns (string memory) |
| 136 | { |
| 137 | return keyExists(json, key) ? readString(json, key) : defaultValue; |
| 138 | } |
| 139 | |
| 140 | function readStringArrayOr(string memory json, string memory key, string[] memory defaultValue) |
| 141 | internal |
| 142 | view |
| 143 | returns (string[] memory) |
| 144 | { |
| 145 | return keyExists(json, key) ? readStringArray(json, key) : defaultValue; |
| 146 | } |
| 147 | |
| 148 | function readAddressOr(string memory json, string memory key, address defaultValue) |
| 149 | internal |
| 150 | view |
| 151 | returns (address) |
| 152 | { |
| 153 | return keyExists(json, key) ? readAddress(json, key) : defaultValue; |
| 154 | } |
| 155 | |
| 156 | function readAddressArrayOr(string memory json, string memory key, address[] memory defaultValue) |
| 157 | internal |
| 158 | view |
| 159 | returns (address[] memory) |
| 160 | { |
| 161 | return keyExists(json, key) ? readAddressArray(json, key) : defaultValue; |
| 162 | } |
| 163 | |
| 164 | function readBoolOr(string memory json, string memory key, bool defaultValue) internal view returns (bool) { |
| 165 | return keyExists(json, key) ? readBool(json, key) : defaultValue; |
| 166 | } |
| 167 | |
| 168 | function readBoolArrayOr(string memory json, string memory key, bool[] memory defaultValue) |
| 169 | internal |
| 170 | view |
| 171 | returns (bool[] memory) |
| 172 | { |
| 173 | return keyExists(json, key) ? readBoolArray(json, key) : defaultValue; |
| 174 | } |
| 175 | |
| 176 | function readBytesOr(string memory json, string memory key, bytes memory defaultValue) |
| 177 | internal |
| 178 | view |
| 179 | returns (bytes memory) |
| 180 | { |
| 181 | return keyExists(json, key) ? readBytes(json, key) : defaultValue; |
| 182 | } |
| 183 | |
| 184 | function readBytesArrayOr(string memory json, string memory key, bytes[] memory defaultValue) |
| 185 | internal |
| 186 | view |
| 187 | returns (bytes[] memory) |
| 188 | { |
| 189 | return keyExists(json, key) ? readBytesArray(json, key) : defaultValue; |
| 190 | } |
| 191 | |
| 192 | function serialize(string memory jsonKey, string memory rootObject) internal returns (string memory) { |
| 193 | return vm.serializeJson(jsonKey, rootObject); |
| 194 | } |
| 195 | |
| 196 | function serialize(string memory jsonKey, string memory key, bool value) internal returns (string memory) { |
| 197 | return vm.serializeBool(jsonKey, key, value); |
| 198 | } |
| 199 | |
| 200 | function serialize(string memory jsonKey, string memory key, bool[] memory value) internal returns (string memory) { |
| 201 | return vm.serializeBool(jsonKey, key, value); |
| 202 | } |
| 203 | |
| 204 | function serialize(string memory jsonKey, string memory key, uint256 value) internal returns (string memory) { |
| 205 | return vm.serializeUint(jsonKey, key, value); |
| 206 | } |
| 207 | |
| 208 | function serialize(string memory jsonKey, string memory key, uint256[] memory value) |
| 209 | internal |
| 210 | returns (string memory) |
| 211 | { |
| 212 | return vm.serializeUint(jsonKey, key, value); |
| 213 | } |
| 214 | |
| 215 | function serialize(string memory jsonKey, string memory key, int256 value) internal returns (string memory) { |
| 216 | return vm.serializeInt(jsonKey, key, value); |
| 217 | } |
| 218 | |
| 219 | function serialize(string memory jsonKey, string memory key, int256[] memory value) |
| 220 | internal |
| 221 | returns (string memory) |
| 222 | { |
| 223 | return vm.serializeInt(jsonKey, key, value); |
| 224 | } |
| 225 | |
| 226 | function serialize(string memory jsonKey, string memory key, address value) internal returns (string memory) { |
| 227 | return vm.serializeAddress(jsonKey, key, value); |
| 228 | } |
| 229 | |
| 230 | function serialize(string memory jsonKey, string memory key, address[] memory value) |
| 231 | internal |
| 232 | returns (string memory) |
| 233 | { |
| 234 | return vm.serializeAddress(jsonKey, key, value); |
| 235 | } |
| 236 | |
| 237 | function serialize(string memory jsonKey, string memory key, bytes32 value) internal returns (string memory) { |
| 238 | return vm.serializeBytes32(jsonKey, key, value); |
| 239 | } |
| 240 | |
| 241 | function serialize(string memory jsonKey, string memory key, bytes32[] memory value) |
| 242 | internal |
| 243 | returns (string memory) |
| 244 | { |
| 245 | return vm.serializeBytes32(jsonKey, key, value); |
| 246 | } |
| 247 | |
| 248 | function serialize(string memory jsonKey, string memory key, bytes memory value) internal returns (string memory) { |
| 249 | return vm.serializeBytes(jsonKey, key, value); |
| 250 | } |
| 251 | |
| 252 | function serialize(string memory jsonKey, string memory key, bytes[] memory value) |
| 253 | internal |
| 254 | returns (string memory) |
| 255 | { |
| 256 | return vm.serializeBytes(jsonKey, key, value); |
| 257 | } |
| 258 | |
| 259 | function serialize(string memory jsonKey, string memory key, string memory value) internal returns (string memory) { |
| 260 | return vm.serializeString(jsonKey, key, value); |
| 261 | } |
| 262 | |
| 263 | function serialize(string memory jsonKey, string memory key, string[] memory value) |
| 264 | internal |
| 265 | returns (string memory) |
| 266 | { |
| 267 | return vm.serializeString(jsonKey, key, value); |
| 268 | } |
| 269 | |
| 270 | function write(string memory jsonKey, string memory path) internal { |
| 271 | vm.writeJson(jsonKey, path); |
| 272 | } |
| 273 | |
| 274 | function write(string memory jsonKey, string memory path, string memory valueKey) internal { |
| 275 | vm.writeJson(jsonKey, path, valueKey); |
| 276 | } |
| 277 | } |
| 278 |
0.0%
lib/forge-std/src/StdMath.sol
Lines covered: 0 / 1 (0.0%)
| 1 | // SPDX-License-Identifier: MIT |
| 2 | pragma solidity >=0.6.2 <0.9.0; |
| 3 | |
| 4 | library stdMath { |
| 5 | int256 private constant INT256_MIN = -57896044618658097711785492504343953926634992332820282019728792003956564819968; |
| 6 | |
| 7 | function abs(int256 a) internal pure returns (uint256) { |
| 8 | // Required or it will fail when `a = type(int256).min` |
| 9 | if (a == INT256_MIN) { |
| 10 | return 57896044618658097711785492504343953926634992332820282019728792003956564819968; |
| 11 | } |
| 12 | |
| 13 | return uint256(a > 0 ? a : -a); |
| 14 | } |
| 15 | |
| 16 | function delta(uint256 a, uint256 b) internal pure returns (uint256) { |
| 17 | return a > b ? a - b : b - a; |
| 18 | } |
| 19 | |
| 20 | function delta(int256 a, int256 b) internal pure returns (uint256) { |
| 21 | // a and b are of the same sign |
| 22 | // this works thanks to two's complement, the left-most bit is the sign bit |
| 23 | if ((a ^ b) > -1) { |
| 24 | return delta(abs(a), abs(b)); |
| 25 | } |
| 26 | |
| 27 | // a and b are of opposite signs |
| 28 | return abs(a) + abs(b); |
| 29 | } |
| 30 | |
| 31 | function percentDelta(uint256 a, uint256 b) internal pure returns (uint256) { |
| 32 | // Prevent division by zero |
| 33 | require(b != 0, "stdMath percentDelta(uint256,uint256): Divisor is zero"); |
| 34 | uint256 absDelta = delta(a, b); |
| 35 | |
| 36 | return absDelta * 1e18 / b; |
| 37 | } |
| 38 | |
| 39 | function percentDelta(int256 a, int256 b) internal pure returns (uint256) { |
| 40 | uint256 absDelta = delta(a, b); |
| 41 | uint256 absB = abs(b); |
| 42 | // Prevent division by zero |
| 43 | require(absB != 0, "stdMath percentDelta(int256,int256): Divisor is zero"); |
| 44 | |
| 45 | return absDelta * 1e18 / absB; |
| 46 | } |
| 47 | } |
| 48 |
0.0%
lib/forge-std/src/StdStorage.sol
Lines covered: 0 / 2 (0.0%)
| 1 | // SPDX-License-Identifier: MIT |
| 2 | pragma solidity >=0.6.2 <0.9.0; |
| 3 | |
| 4 | import {Vm} from "./Vm.sol"; |
| 5 | |
| 6 | struct FindData { |
| 7 | uint256 slot; |
| 8 | uint256 offsetLeft; |
| 9 | uint256 offsetRight; |
| 10 | bool found; |
| 11 | } |
| 12 | |
| 13 | struct StdStorage { |
| 14 | mapping(address => mapping(bytes4 => mapping(bytes32 => FindData))) finds; |
| 15 | bytes32[] _keys; |
| 16 | bytes4 _sig; |
| 17 | uint256 _depth; |
| 18 | address _target; |
| 19 | bytes32 _set; |
| 20 | bool _enable_packed_slots; |
| 21 | bytes _calldata; |
| 22 | } |
| 23 | |
| 24 | library stdStorageSafe { |
| 25 | event SlotFound(address who, bytes4 fsig, bytes32 keysHash, uint256 slot); |
| 26 | event WARNING_UninitedSlot(address who, uint256 slot); |
| 27 | |
| 28 | Vm private constant vm = Vm(address(uint160(uint256(keccak256("hevm cheat code"))))); |
| 29 | uint256 constant UINT256_MAX = 115792089237316195423570985008687907853269984665640564039457584007913129639935; |
| 30 | |
| 31 | function sigs(string memory sigStr) internal pure returns (bytes4) { |
| 32 | return bytes4(keccak256(bytes(sigStr))); |
| 33 | } |
| 34 | |
| 35 | function getCallParams(StdStorage storage self) internal view returns (bytes memory) { |
| 36 | if (self._calldata.length == 0) { |
| 37 | return flatten(self._keys); |
| 38 | } else { |
| 39 | return self._calldata; |
| 40 | } |
| 41 | } |
| 42 | |
| 43 | // Calls target contract with configured parameters |
| 44 | function callTarget(StdStorage storage self) internal view returns (bool, bytes32) { |
| 45 | bytes memory cd = abi.encodePacked(self._sig, getCallParams(self)); |
| 46 | (bool success, bytes memory rdat) = self._target.staticcall(cd); |
| 47 | bytes32 result = bytesToBytes32(rdat, 32 * self._depth); |
| 48 | |
| 49 | return (success, result); |
| 50 | } |
| 51 | |
| 52 | // Tries mutating slot value to determine if the targeted value is stored in it. |
| 53 | // If current value is 0, then we are setting slot value to type(uint256).max |
| 54 | // Otherwise, we set it to 0. That way, return value should always be affected. |
| 55 | function checkSlotMutatesCall(StdStorage storage self, bytes32 slot) internal returns (bool) { |
| 56 | bytes32 prevSlotValue = vm.load(self._target, slot); |
| 57 | (bool success, bytes32 prevReturnValue) = callTarget(self); |
| 58 | |
| 59 | bytes32 testVal = prevReturnValue == bytes32(0) ? bytes32(UINT256_MAX) : bytes32(0); |
| 60 | vm.store(self._target, slot, testVal); |
| 61 | |
| 62 | (, bytes32 newReturnValue) = callTarget(self); |
| 63 | |
| 64 | vm.store(self._target, slot, prevSlotValue); |
| 65 | |
| 66 | return (success && (prevReturnValue != newReturnValue)); |
| 67 | } |
| 68 | |
| 69 | // Tries setting one of the bits in slot to 1 until return value changes. |
| 70 | // Index of resulted bit is an offset packed slot has from left/right side |
| 71 | function findOffset(StdStorage storage self, bytes32 slot, bool left) internal returns (bool, uint256) { |
| 72 | for (uint256 offset = 0; offset < 256; offset++) { |
| 73 | uint256 valueToPut = left ? (1 << (255 - offset)) : (1 << offset); |
| 74 | vm.store(self._target, slot, bytes32(valueToPut)); |
| 75 | |
| 76 | (bool success, bytes32 data) = callTarget(self); |
| 77 | |
| 78 | if (success && (uint256(data) > 0)) { |
| 79 | return (true, offset); |
| 80 | } |
| 81 | } |
| 82 | return (false, 0); |
| 83 | } |
| 84 | |
| 85 | function findOffsets(StdStorage storage self, bytes32 slot) internal returns (bool, uint256, uint256) { |
| 86 | bytes32 prevSlotValue = vm.load(self._target, slot); |
| 87 | |
| 88 | (bool foundLeft, uint256 offsetLeft) = findOffset(self, slot, true); |
| 89 | (bool foundRight, uint256 offsetRight) = findOffset(self, slot, false); |
| 90 | |
| 91 | // `findOffset` may mutate slot value, so we are setting it to initial value |
| 92 | vm.store(self._target, slot, prevSlotValue); |
| 93 | return (foundLeft && foundRight, offsetLeft, offsetRight); |
| 94 | } |
| 95 | |
| 96 | function find(StdStorage storage self) internal returns (FindData storage) { |
| 97 | return find(self, true); |
| 98 | } |
| 99 | |
| 100 | /// @notice find an arbitrary storage slot given a function sig, input data, address of the contract and a value to check against |
| 101 | // slot complexity: |
| 102 | // if flat, will be bytes32(uint256(uint)); |
| 103 | // if map, will be keccak256(abi.encode(key, uint(slot))); |
| 104 | // if deep map, will be keccak256(abi.encode(key1, keccak256(abi.encode(key0, uint(slot))))); |
| 105 | // if map struct, will be bytes32(uint256(keccak256(abi.encode(key1, keccak256(abi.encode(key0, uint(slot)))))) + structFieldDepth); |
| 106 | function find(StdStorage storage self, bool _clear) internal returns (FindData storage) { |
| 107 | address who = self._target; |
| 108 | bytes4 fsig = self._sig; |
| 109 | uint256 field_depth = self._depth; |
| 110 | bytes memory params = getCallParams(self); |
| 111 | |
| 112 | // calldata to test against |
| 113 | if (self.finds[who][fsig][keccak256(abi.encodePacked(params, field_depth))].found) { |
| 114 | if (_clear) { |
| 115 | clear(self); |
| 116 | } |
| 117 | return self.finds[who][fsig][keccak256(abi.encodePacked(params, field_depth))]; |
| 118 | } |
| 119 | vm.record(); |
| 120 | (, bytes32 callResult) = callTarget(self); |
| 121 | (bytes32[] memory reads,) = vm.accesses(address(who)); |
| 122 | |
| 123 | if (reads.length == 0) { |
| 124 | revert("stdStorage find(StdStorage): No storage use detected for target."); |
| 125 | } else { |
| 126 | for (uint256 i = reads.length; --i >= 0;) { |
| 127 | bytes32 prev = vm.load(who, reads[i]); |
| 128 | if (prev == bytes32(0)) { |
| 129 | emit WARNING_UninitedSlot(who, uint256(reads[i])); |
| 130 | } |
| 131 | |
| 132 | if (!checkSlotMutatesCall(self, reads[i])) { |
| 133 | continue; |
| 134 | } |
| 135 | |
| 136 | (uint256 offsetLeft, uint256 offsetRight) = (0, 0); |
| 137 | |
| 138 | if (self._enable_packed_slots) { |
| 139 | bool found; |
| 140 | (found, offsetLeft, offsetRight) = findOffsets(self, reads[i]); |
| 141 | if (!found) { |
| 142 | continue; |
| 143 | } |
| 144 | } |
| 145 | |
| 146 | // Check that value between found offsets is equal to the current call result |
| 147 | uint256 curVal = (uint256(prev) & getMaskByOffsets(offsetLeft, offsetRight)) >> offsetRight; |
| 148 | |
| 149 | if (uint256(callResult) != curVal) { |
| 150 | continue; |
| 151 | } |
| 152 | |
| 153 | emit SlotFound(who, fsig, keccak256(abi.encodePacked(params, field_depth)), uint256(reads[i])); |
| 154 | self.finds[who][fsig][keccak256(abi.encodePacked(params, field_depth))] = |
| 155 | FindData(uint256(reads[i]), offsetLeft, offsetRight, true); |
| 156 | break; |
| 157 | } |
| 158 | } |
| 159 | |
| 160 | require( |
| 161 | self.finds[who][fsig][keccak256(abi.encodePacked(params, field_depth))].found, |
| 162 | "stdStorage find(StdStorage): Slot(s) not found." |
| 163 | ); |
| 164 | |
| 165 | if (_clear) { |
| 166 | clear(self); |
| 167 | } |
| 168 | return self.finds[who][fsig][keccak256(abi.encodePacked(params, field_depth))]; |
| 169 | } |
| 170 | |
| 171 | function target(StdStorage storage self, address _target) internal returns (StdStorage storage) { |
| 172 | self._target = _target; |
| 173 | return self; |
| 174 | } |
| 175 | |
| 176 | function sig(StdStorage storage self, bytes4 _sig) internal returns (StdStorage storage) { |
| 177 | self._sig = _sig; |
| 178 | return self; |
| 179 | } |
| 180 | |
| 181 | function sig(StdStorage storage self, string memory _sig) internal returns (StdStorage storage) { |
| 182 | self._sig = sigs(_sig); |
| 183 | return self; |
| 184 | } |
| 185 | |
| 186 | function with_calldata(StdStorage storage self, bytes memory _calldata) internal returns (StdStorage storage) { |
| 187 | self._calldata = _calldata; |
| 188 | return self; |
| 189 | } |
| 190 | |
| 191 | function with_key(StdStorage storage self, address who) internal returns (StdStorage storage) { |
| 192 | self._keys.push(bytes32(uint256(uint160(who)))); |
| 193 | return self; |
| 194 | } |
| 195 | |
| 196 | function with_key(StdStorage storage self, uint256 amt) internal returns (StdStorage storage) { |
| 197 | self._keys.push(bytes32(amt)); |
| 198 | return self; |
| 199 | } |
| 200 | |
| 201 | function with_key(StdStorage storage self, bytes32 key) internal returns (StdStorage storage) { |
| 202 | self._keys.push(key); |
| 203 | return self; |
| 204 | } |
| 205 | |
| 206 | function enable_packed_slots(StdStorage storage self) internal returns (StdStorage storage) { |
| 207 | self._enable_packed_slots = true; |
| 208 | return self; |
| 209 | } |
| 210 | |
| 211 | function depth(StdStorage storage self, uint256 _depth) internal returns (StdStorage storage) { |
| 212 | self._depth = _depth; |
| 213 | return self; |
| 214 | } |
| 215 | |
| 216 | function read(StdStorage storage self) private returns (bytes memory) { |
| 217 | FindData storage data = find(self, false); |
| 218 | uint256 mask = getMaskByOffsets(data.offsetLeft, data.offsetRight); |
| 219 | uint256 value = (uint256(vm.load(self._target, bytes32(data.slot))) & mask) >> data.offsetRight; |
| 220 | clear(self); |
| 221 | return abi.encode(value); |
| 222 | } |
| 223 | |
| 224 | function read_bytes32(StdStorage storage self) internal returns (bytes32) { |
| 225 | return abi.decode(read(self), (bytes32)); |
| 226 | } |
| 227 | |
| 228 | function read_bool(StdStorage storage self) internal returns (bool) { |
| 229 | int256 v = read_int(self); |
| 230 | if (v == 0) return false; |
| 231 | if (v == 1) return true; |
| 232 | revert("stdStorage read_bool(StdStorage): Cannot decode. Make sure you are reading a bool."); |
| 233 | } |
| 234 | |
| 235 | function read_address(StdStorage storage self) internal returns (address) { |
| 236 | return abi.decode(read(self), (address)); |
| 237 | } |
| 238 | |
| 239 | function read_uint(StdStorage storage self) internal returns (uint256) { |
| 240 | return abi.decode(read(self), (uint256)); |
| 241 | } |
| 242 | |
| 243 | function read_int(StdStorage storage self) internal returns (int256) { |
| 244 | return abi.decode(read(self), (int256)); |
| 245 | } |
| 246 | |
| 247 | function parent(StdStorage storage self) internal returns (uint256, bytes32) { |
| 248 | address who = self._target; |
| 249 | uint256 field_depth = self._depth; |
| 250 | vm.startMappingRecording(); |
| 251 | uint256 child = find(self, true).slot - field_depth; |
| 252 | (bool found, bytes32 key, bytes32 parent_slot) = vm.getMappingKeyAndParentOf(who, bytes32(child)); |
| 253 | if (!found) { |
| 254 | revert( |
| 255 | "stdStorage read_bool(StdStorage): Cannot find parent. Make sure you give a slot and startMappingRecording() has been called." |
| 256 | ); |
| 257 | } |
| 258 | return (uint256(parent_slot), key); |
| 259 | } |
| 260 | |
| 261 | function root(StdStorage storage self) internal returns (uint256) { |
| 262 | address who = self._target; |
| 263 | uint256 field_depth = self._depth; |
| 264 | vm.startMappingRecording(); |
| 265 | uint256 child = find(self, true).slot - field_depth; |
| 266 | bool found; |
| 267 | bytes32 root_slot; |
| 268 | bytes32 parent_slot; |
| 269 | (found,, parent_slot) = vm.getMappingKeyAndParentOf(who, bytes32(child)); |
| 270 | if (!found) { |
| 271 | revert( |
| 272 | "stdStorage read_bool(StdStorage): Cannot find parent. Make sure you give a slot and startMappingRecording() has been called." |
| 273 | ); |
| 274 | } |
| 275 | while (found) { |
| 276 | root_slot = parent_slot; |
| 277 | (found,, parent_slot) = vm.getMappingKeyAndParentOf(who, bytes32(root_slot)); |
| 278 | } |
| 279 | return uint256(root_slot); |
| 280 | } |
| 281 | |
| 282 | function bytesToBytes32(bytes memory b, uint256 offset) private pure returns (bytes32) { |
| 283 | bytes32 out; |
| 284 | |
| 285 | uint256 max = b.length > 32 ? 32 : b.length; |
| 286 | for (uint256 i = 0; i < max; i++) { |
| 287 | out |= bytes32(b[offset + i] & 0xFF) >> (i * 8); |
| 288 | } |
| 289 | return out; |
| 290 | } |
| 291 | |
| 292 | function flatten(bytes32[] memory b) private pure returns (bytes memory) { |
| 293 | bytes memory result = new bytes(b.length * 32); |
| 294 | for (uint256 i = 0; i < b.length; i++) { |
| 295 | bytes32 k = b[i]; |
| 296 | /// @solidity memory-safe-assembly |
| 297 | assembly { |
| 298 | mstore(add(result, add(32, mul(32, i))), k) |
| 299 | } |
| 300 | } |
| 301 | |
| 302 | return result; |
| 303 | } |
| 304 | |
| 305 | function clear(StdStorage storage self) internal { |
| 306 | delete self._target; |
| 307 | delete self._sig; |
| 308 | delete self._keys; |
| 309 | delete self._depth; |
| 310 | delete self._enable_packed_slots; |
| 311 | delete self._calldata; |
| 312 | } |
| 313 | |
| 314 | // Returns mask which contains non-zero bits for values between `offsetLeft` and `offsetRight` |
| 315 | // (slotValue & mask) >> offsetRight will be the value of the given packed variable |
| 316 | function getMaskByOffsets(uint256 offsetLeft, uint256 offsetRight) internal pure returns (uint256 mask) { |
| 317 | // mask = ((1 << (256 - (offsetRight + offsetLeft))) - 1) << offsetRight; |
| 318 | // using assembly because (1 << 256) causes overflow |
| 319 | assembly { |
| 320 | mask := shl(offsetRight, sub(shl(sub(256, add(offsetRight, offsetLeft)), 1), 1)) |
| 321 | } |
| 322 | } |
| 323 | |
| 324 | // Returns slot value with updated packed variable. |
| 325 | function getUpdatedSlotValue(bytes32 curValue, uint256 varValue, uint256 offsetLeft, uint256 offsetRight) |
| 326 | internal |
| 327 | pure |
| 328 | returns (bytes32 newValue) |
| 329 | { |
| 330 | return bytes32((uint256(curValue) & ~getMaskByOffsets(offsetLeft, offsetRight)) | (varValue << offsetRight)); |
| 331 | } |
| 332 | } |
| 333 | |
| 334 | library stdStorage { |
| 335 | Vm private constant vm = Vm(address(uint160(uint256(keccak256("hevm cheat code"))))); |
| 336 | |
| 337 | function sigs(string memory sigStr) internal pure returns (bytes4) { |
| 338 | return stdStorageSafe.sigs(sigStr); |
| 339 | } |
| 340 | |
| 341 | function find(StdStorage storage self) internal returns (uint256) { |
| 342 | return find(self, true); |
| 343 | } |
| 344 | |
| 345 | function find(StdStorage storage self, bool _clear) internal returns (uint256) { |
| 346 | return stdStorageSafe.find(self, _clear).slot; |
| 347 | } |
| 348 | |
| 349 | function target(StdStorage storage self, address _target) internal returns (StdStorage storage) { |
| 350 | return stdStorageSafe.target(self, _target); |
| 351 | } |
| 352 | |
| 353 | function sig(StdStorage storage self, bytes4 _sig) internal returns (StdStorage storage) { |
| 354 | return stdStorageSafe.sig(self, _sig); |
| 355 | } |
| 356 | |
| 357 | function sig(StdStorage storage self, string memory _sig) internal returns (StdStorage storage) { |
| 358 | return stdStorageSafe.sig(self, _sig); |
| 359 | } |
| 360 | |
| 361 | function with_key(StdStorage storage self, address who) internal returns (StdStorage storage) { |
| 362 | return stdStorageSafe.with_key(self, who); |
| 363 | } |
| 364 | |
| 365 | function with_key(StdStorage storage self, uint256 amt) internal returns (StdStorage storage) { |
| 366 | return stdStorageSafe.with_key(self, amt); |
| 367 | } |
| 368 | |
| 369 | function with_key(StdStorage storage self, bytes32 key) internal returns (StdStorage storage) { |
| 370 | return stdStorageSafe.with_key(self, key); |
| 371 | } |
| 372 | |
| 373 | function with_calldata(StdStorage storage self, bytes memory _calldata) internal returns (StdStorage storage) { |
| 374 | return stdStorageSafe.with_calldata(self, _calldata); |
| 375 | } |
| 376 | |
| 377 | function enable_packed_slots(StdStorage storage self) internal returns (StdStorage storage) { |
| 378 | return stdStorageSafe.enable_packed_slots(self); |
| 379 | } |
| 380 | |
| 381 | function depth(StdStorage storage self, uint256 _depth) internal returns (StdStorage storage) { |
| 382 | return stdStorageSafe.depth(self, _depth); |
| 383 | } |
| 384 | |
| 385 | function clear(StdStorage storage self) internal { |
| 386 | stdStorageSafe.clear(self); |
| 387 | } |
| 388 | |
| 389 | function checked_write(StdStorage storage self, address who) internal { |
| 390 | checked_write(self, bytes32(uint256(uint160(who)))); |
| 391 | } |
| 392 | |
| 393 | function checked_write(StdStorage storage self, uint256 amt) internal { |
| 394 | checked_write(self, bytes32(amt)); |
| 395 | } |
| 396 | |
| 397 | function checked_write_int(StdStorage storage self, int256 val) internal { |
| 398 | checked_write(self, bytes32(uint256(val))); |
| 399 | } |
| 400 | |
| 401 | function checked_write(StdStorage storage self, bool write) internal { |
| 402 | bytes32 t; |
| 403 | /// @solidity memory-safe-assembly |
| 404 | assembly { |
| 405 | t := write |
| 406 | } |
| 407 | checked_write(self, t); |
| 408 | } |
| 409 | |
| 410 | function checked_write(StdStorage storage self, bytes32 set) internal { |
| 411 | address who = self._target; |
| 412 | bytes4 fsig = self._sig; |
| 413 | uint256 field_depth = self._depth; |
| 414 | bytes memory params = stdStorageSafe.getCallParams(self); |
| 415 | |
| 416 | if (!self.finds[who][fsig][keccak256(abi.encodePacked(params, field_depth))].found) { |
| 417 | find(self, false); |
| 418 | } |
| 419 | FindData storage data = self.finds[who][fsig][keccak256(abi.encodePacked(params, field_depth))]; |
| 420 | if ((data.offsetLeft + data.offsetRight) > 0) { |
| 421 | uint256 maxVal = 2 ** (256 - (data.offsetLeft + data.offsetRight)); |
| 422 | require( |
| 423 | uint256(set) < maxVal, |
| 424 | string( |
| 425 | abi.encodePacked( |
| 426 | "stdStorage find(StdStorage): Packed slot. We can't fit value greater than ", |
| 427 | vm.toString(maxVal) |
| 428 | ) |
| 429 | ) |
| 430 | ); |
| 431 | } |
| 432 | bytes32 curVal = vm.load(who, bytes32(data.slot)); |
| 433 | bytes32 valToSet = stdStorageSafe.getUpdatedSlotValue(curVal, uint256(set), data.offsetLeft, data.offsetRight); |
| 434 | |
| 435 | vm.store(who, bytes32(data.slot), valToSet); |
| 436 | |
| 437 | (bool success, bytes32 callResult) = stdStorageSafe.callTarget(self); |
| 438 | |
| 439 | if (!success || callResult != set) { |
| 440 | vm.store(who, bytes32(data.slot), curVal); |
| 441 | revert("stdStorage find(StdStorage): Failed to write value."); |
| 442 | } |
| 443 | clear(self); |
| 444 | } |
| 445 | |
| 446 | function read_bytes32(StdStorage storage self) internal returns (bytes32) { |
| 447 | return stdStorageSafe.read_bytes32(self); |
| 448 | } |
| 449 | |
| 450 | function read_bool(StdStorage storage self) internal returns (bool) { |
| 451 | return stdStorageSafe.read_bool(self); |
| 452 | } |
| 453 | |
| 454 | function read_address(StdStorage storage self) internal returns (address) { |
| 455 | return stdStorageSafe.read_address(self); |
| 456 | } |
| 457 | |
| 458 | function read_uint(StdStorage storage self) internal returns (uint256) { |
| 459 | return stdStorageSafe.read_uint(self); |
| 460 | } |
| 461 | |
| 462 | function read_int(StdStorage storage self) internal returns (int256) { |
| 463 | return stdStorageSafe.read_int(self); |
| 464 | } |
| 465 | |
| 466 | function parent(StdStorage storage self) internal returns (uint256, bytes32) { |
| 467 | return stdStorageSafe.parent(self); |
| 468 | } |
| 469 | |
| 470 | function root(StdStorage storage self) internal returns (uint256) { |
| 471 | return stdStorageSafe.root(self); |
| 472 | } |
| 473 | } |
| 474 |
0.0%
lib/forge-std/src/StdStyle.sol
Lines covered: 0 / 1 (0.0%)
| 1 | // SPDX-License-Identifier: MIT |
| 2 | pragma solidity >=0.4.22 <0.9.0; |
| 3 | |
| 4 | import {VmSafe} from "./Vm.sol"; |
| 5 | |
| 6 | library StdStyle { |
| 7 | VmSafe private constant vm = VmSafe(address(uint160(uint256(keccak256("hevm cheat code"))))); |
| 8 | |
| 9 | string constant RED = "\u001b[91m"; |
| 10 | string constant GREEN = "\u001b[92m"; |
| 11 | string constant YELLOW = "\u001b[93m"; |
| 12 | string constant BLUE = "\u001b[94m"; |
| 13 | string constant MAGENTA = "\u001b[95m"; |
| 14 | string constant CYAN = "\u001b[96m"; |
| 15 | string constant BOLD = "\u001b[1m"; |
| 16 | string constant DIM = "\u001b[2m"; |
| 17 | string constant ITALIC = "\u001b[3m"; |
| 18 | string constant UNDERLINE = "\u001b[4m"; |
| 19 | string constant INVERSE = "\u001b[7m"; |
| 20 | string constant RESET = "\u001b[0m"; |
| 21 | |
| 22 | function styleConcat(string memory style, string memory self) private pure returns (string memory) { |
| 23 | return string(abi.encodePacked(style, self, RESET)); |
| 24 | } |
| 25 | |
| 26 | function red(string memory self) internal pure returns (string memory) { |
| 27 | return styleConcat(RED, self); |
| 28 | } |
| 29 | |
| 30 | function red(uint256 self) internal pure returns (string memory) { |
| 31 | return red(vm.toString(self)); |
| 32 | } |
| 33 | |
| 34 | function red(int256 self) internal pure returns (string memory) { |
| 35 | return red(vm.toString(self)); |
| 36 | } |
| 37 | |
| 38 | function red(address self) internal pure returns (string memory) { |
| 39 | return red(vm.toString(self)); |
| 40 | } |
| 41 | |
| 42 | function red(bool self) internal pure returns (string memory) { |
| 43 | return red(vm.toString(self)); |
| 44 | } |
| 45 | |
| 46 | function redBytes(bytes memory self) internal pure returns (string memory) { |
| 47 | return red(vm.toString(self)); |
| 48 | } |
| 49 | |
| 50 | function redBytes32(bytes32 self) internal pure returns (string memory) { |
| 51 | return red(vm.toString(self)); |
| 52 | } |
| 53 | |
| 54 | function green(string memory self) internal pure returns (string memory) { |
| 55 | return styleConcat(GREEN, self); |
| 56 | } |
| 57 | |
| 58 | function green(uint256 self) internal pure returns (string memory) { |
| 59 | return green(vm.toString(self)); |
| 60 | } |
| 61 | |
| 62 | function green(int256 self) internal pure returns (string memory) { |
| 63 | return green(vm.toString(self)); |
| 64 | } |
| 65 | |
| 66 | function green(address self) internal pure returns (string memory) { |
| 67 | return green(vm.toString(self)); |
| 68 | } |
| 69 | |
| 70 | function green(bool self) internal pure returns (string memory) { |
| 71 | return green(vm.toString(self)); |
| 72 | } |
| 73 | |
| 74 | function greenBytes(bytes memory self) internal pure returns (string memory) { |
| 75 | return green(vm.toString(self)); |
| 76 | } |
| 77 | |
| 78 | function greenBytes32(bytes32 self) internal pure returns (string memory) { |
| 79 | return green(vm.toString(self)); |
| 80 | } |
| 81 | |
| 82 | function yellow(string memory self) internal pure returns (string memory) { |
| 83 | return styleConcat(YELLOW, self); |
| 84 | } |
| 85 | |
| 86 | function yellow(uint256 self) internal pure returns (string memory) { |
| 87 | return yellow(vm.toString(self)); |
| 88 | } |
| 89 | |
| 90 | function yellow(int256 self) internal pure returns (string memory) { |
| 91 | return yellow(vm.toString(self)); |
| 92 | } |
| 93 | |
| 94 | function yellow(address self) internal pure returns (string memory) { |
| 95 | return yellow(vm.toString(self)); |
| 96 | } |
| 97 | |
| 98 | function yellow(bool self) internal pure returns (string memory) { |
| 99 | return yellow(vm.toString(self)); |
| 100 | } |
| 101 | |
| 102 | function yellowBytes(bytes memory self) internal pure returns (string memory) { |
| 103 | return yellow(vm.toString(self)); |
| 104 | } |
| 105 | |
| 106 | function yellowBytes32(bytes32 self) internal pure returns (string memory) { |
| 107 | return yellow(vm.toString(self)); |
| 108 | } |
| 109 | |
| 110 | function blue(string memory self) internal pure returns (string memory) { |
| 111 | return styleConcat(BLUE, self); |
| 112 | } |
| 113 | |
| 114 | function blue(uint256 self) internal pure returns (string memory) { |
| 115 | return blue(vm.toString(self)); |
| 116 | } |
| 117 | |
| 118 | function blue(int256 self) internal pure returns (string memory) { |
| 119 | return blue(vm.toString(self)); |
| 120 | } |
| 121 | |
| 122 | function blue(address self) internal pure returns (string memory) { |
| 123 | return blue(vm.toString(self)); |
| 124 | } |
| 125 | |
| 126 | function blue(bool self) internal pure returns (string memory) { |
| 127 | return blue(vm.toString(self)); |
| 128 | } |
| 129 | |
| 130 | function blueBytes(bytes memory self) internal pure returns (string memory) { |
| 131 | return blue(vm.toString(self)); |
| 132 | } |
| 133 | |
| 134 | function blueBytes32(bytes32 self) internal pure returns (string memory) { |
| 135 | return blue(vm.toString(self)); |
| 136 | } |
| 137 | |
| 138 | function magenta(string memory self) internal pure returns (string memory) { |
| 139 | return styleConcat(MAGENTA, self); |
| 140 | } |
| 141 | |
| 142 | function magenta(uint256 self) internal pure returns (string memory) { |
| 143 | return magenta(vm.toString(self)); |
| 144 | } |
| 145 | |
| 146 | function magenta(int256 self) internal pure returns (string memory) { |
| 147 | return magenta(vm.toString(self)); |
| 148 | } |
| 149 | |
| 150 | function magenta(address self) internal pure returns (string memory) { |
| 151 | return magenta(vm.toString(self)); |
| 152 | } |
| 153 | |
| 154 | function magenta(bool self) internal pure returns (string memory) { |
| 155 | return magenta(vm.toString(self)); |
| 156 | } |
| 157 | |
| 158 | function magentaBytes(bytes memory self) internal pure returns (string memory) { |
| 159 | return magenta(vm.toString(self)); |
| 160 | } |
| 161 | |
| 162 | function magentaBytes32(bytes32 self) internal pure returns (string memory) { |
| 163 | return magenta(vm.toString(self)); |
| 164 | } |
| 165 | |
| 166 | function cyan(string memory self) internal pure returns (string memory) { |
| 167 | return styleConcat(CYAN, self); |
| 168 | } |
| 169 | |
| 170 | function cyan(uint256 self) internal pure returns (string memory) { |
| 171 | return cyan(vm.toString(self)); |
| 172 | } |
| 173 | |
| 174 | function cyan(int256 self) internal pure returns (string memory) { |
| 175 | return cyan(vm.toString(self)); |
| 176 | } |
| 177 | |
| 178 | function cyan(address self) internal pure returns (string memory) { |
| 179 | return cyan(vm.toString(self)); |
| 180 | } |
| 181 | |
| 182 | function cyan(bool self) internal pure returns (string memory) { |
| 183 | return cyan(vm.toString(self)); |
| 184 | } |
| 185 | |
| 186 | function cyanBytes(bytes memory self) internal pure returns (string memory) { |
| 187 | return cyan(vm.toString(self)); |
| 188 | } |
| 189 | |
| 190 | function cyanBytes32(bytes32 self) internal pure returns (string memory) { |
| 191 | return cyan(vm.toString(self)); |
| 192 | } |
| 193 | |
| 194 | function bold(string memory self) internal pure returns (string memory) { |
| 195 | return styleConcat(BOLD, self); |
| 196 | } |
| 197 | |
| 198 | function bold(uint256 self) internal pure returns (string memory) { |
| 199 | return bold(vm.toString(self)); |
| 200 | } |
| 201 | |
| 202 | function bold(int256 self) internal pure returns (string memory) { |
| 203 | return bold(vm.toString(self)); |
| 204 | } |
| 205 | |
| 206 | function bold(address self) internal pure returns (string memory) { |
| 207 | return bold(vm.toString(self)); |
| 208 | } |
| 209 | |
| 210 | function bold(bool self) internal pure returns (string memory) { |
| 211 | return bold(vm.toString(self)); |
| 212 | } |
| 213 | |
| 214 | function boldBytes(bytes memory self) internal pure returns (string memory) { |
| 215 | return bold(vm.toString(self)); |
| 216 | } |
| 217 | |
| 218 | function boldBytes32(bytes32 self) internal pure returns (string memory) { |
| 219 | return bold(vm.toString(self)); |
| 220 | } |
| 221 | |
| 222 | function dim(string memory self) internal pure returns (string memory) { |
| 223 | return styleConcat(DIM, self); |
| 224 | } |
| 225 | |
| 226 | function dim(uint256 self) internal pure returns (string memory) { |
| 227 | return dim(vm.toString(self)); |
| 228 | } |
| 229 | |
| 230 | function dim(int256 self) internal pure returns (string memory) { |
| 231 | return dim(vm.toString(self)); |
| 232 | } |
| 233 | |
| 234 | function dim(address self) internal pure returns (string memory) { |
| 235 | return dim(vm.toString(self)); |
| 236 | } |
| 237 | |
| 238 | function dim(bool self) internal pure returns (string memory) { |
| 239 | return dim(vm.toString(self)); |
| 240 | } |
| 241 | |
| 242 | function dimBytes(bytes memory self) internal pure returns (string memory) { |
| 243 | return dim(vm.toString(self)); |
| 244 | } |
| 245 | |
| 246 | function dimBytes32(bytes32 self) internal pure returns (string memory) { |
| 247 | return dim(vm.toString(self)); |
| 248 | } |
| 249 | |
| 250 | function italic(string memory self) internal pure returns (string memory) { |
| 251 | return styleConcat(ITALIC, self); |
| 252 | } |
| 253 | |
| 254 | function italic(uint256 self) internal pure returns (string memory) { |
| 255 | return italic(vm.toString(self)); |
| 256 | } |
| 257 | |
| 258 | function italic(int256 self) internal pure returns (string memory) { |
| 259 | return italic(vm.toString(self)); |
| 260 | } |
| 261 | |
| 262 | function italic(address self) internal pure returns (string memory) { |
| 263 | return italic(vm.toString(self)); |
| 264 | } |
| 265 | |
| 266 | function italic(bool self) internal pure returns (string memory) { |
| 267 | return italic(vm.toString(self)); |
| 268 | } |
| 269 | |
| 270 | function italicBytes(bytes memory self) internal pure returns (string memory) { |
| 271 | return italic(vm.toString(self)); |
| 272 | } |
| 273 | |
| 274 | function italicBytes32(bytes32 self) internal pure returns (string memory) { |
| 275 | return italic(vm.toString(self)); |
| 276 | } |
| 277 | |
| 278 | function underline(string memory self) internal pure returns (string memory) { |
| 279 | return styleConcat(UNDERLINE, self); |
| 280 | } |
| 281 | |
| 282 | function underline(uint256 self) internal pure returns (string memory) { |
| 283 | return underline(vm.toString(self)); |
| 284 | } |
| 285 | |
| 286 | function underline(int256 self) internal pure returns (string memory) { |
| 287 | return underline(vm.toString(self)); |
| 288 | } |
| 289 | |
| 290 | function underline(address self) internal pure returns (string memory) { |
| 291 | return underline(vm.toString(self)); |
| 292 | } |
| 293 | |
| 294 | function underline(bool self) internal pure returns (string memory) { |
| 295 | return underline(vm.toString(self)); |
| 296 | } |
| 297 | |
| 298 | function underlineBytes(bytes memory self) internal pure returns (string memory) { |
| 299 | return underline(vm.toString(self)); |
| 300 | } |
| 301 | |
| 302 | function underlineBytes32(bytes32 self) internal pure returns (string memory) { |
| 303 | return underline(vm.toString(self)); |
| 304 | } |
| 305 | |
| 306 | function inverse(string memory self) internal pure returns (string memory) { |
| 307 | return styleConcat(INVERSE, self); |
| 308 | } |
| 309 | |
| 310 | function inverse(uint256 self) internal pure returns (string memory) { |
| 311 | return inverse(vm.toString(self)); |
| 312 | } |
| 313 | |
| 314 | function inverse(int256 self) internal pure returns (string memory) { |
| 315 | return inverse(vm.toString(self)); |
| 316 | } |
| 317 | |
| 318 | function inverse(address self) internal pure returns (string memory) { |
| 319 | return inverse(vm.toString(self)); |
| 320 | } |
| 321 | |
| 322 | function inverse(bool self) internal pure returns (string memory) { |
| 323 | return inverse(vm.toString(self)); |
| 324 | } |
| 325 | |
| 326 | function inverseBytes(bytes memory self) internal pure returns (string memory) { |
| 327 | return inverse(vm.toString(self)); |
| 328 | } |
| 329 | |
| 330 | function inverseBytes32(bytes32 self) internal pure returns (string memory) { |
| 331 | return inverse(vm.toString(self)); |
| 332 | } |
| 333 | } |
| 334 |
0.0%
lib/forge-std/src/StdToml.sol
Lines covered: 0 / 1 (0.0%)
| 1 | // SPDX-License-Identifier: MIT |
| 2 | pragma solidity >=0.6.0 <0.9.0; |
| 3 | |
| 4 | pragma experimental ABIEncoderV2; |
| 5 | |
| 6 | import {VmSafe} from "./Vm.sol"; |
| 7 | |
| 8 | // Helpers for parsing and writing TOML files |
| 9 | // To parse: |
| 10 | // ``` |
| 11 | // using stdToml for string; |
| 12 | // string memory toml = vm.readFile("<some_path>"); |
| 13 | // toml.readUint("<json_path>"); |
| 14 | // ``` |
| 15 | // To write: |
| 16 | // ``` |
| 17 | // using stdToml for string; |
| 18 | // string memory json = "json"; |
| 19 | // json.serialize("a", uint256(123)); |
| 20 | // string memory semiFinal = json.serialize("b", string("test")); |
| 21 | // string memory finalJson = json.serialize("c", semiFinal); |
| 22 | // finalJson.write("<some_path>"); |
| 23 | // ``` |
| 24 | |
| 25 | library stdToml { |
| 26 | VmSafe private constant vm = VmSafe(address(uint160(uint256(keccak256("hevm cheat code"))))); |
| 27 | |
| 28 | function keyExists(string memory toml, string memory key) internal view returns (bool) { |
| 29 | return vm.keyExistsToml(toml, key); |
| 30 | } |
| 31 | |
| 32 | function parseRaw(string memory toml, string memory key) internal pure returns (bytes memory) { |
| 33 | return vm.parseToml(toml, key); |
| 34 | } |
| 35 | |
| 36 | function readUint(string memory toml, string memory key) internal pure returns (uint256) { |
| 37 | return vm.parseTomlUint(toml, key); |
| 38 | } |
| 39 | |
| 40 | function readUintArray(string memory toml, string memory key) internal pure returns (uint256[] memory) { |
| 41 | return vm.parseTomlUintArray(toml, key); |
| 42 | } |
| 43 | |
| 44 | function readInt(string memory toml, string memory key) internal pure returns (int256) { |
| 45 | return vm.parseTomlInt(toml, key); |
| 46 | } |
| 47 | |
| 48 | function readIntArray(string memory toml, string memory key) internal pure returns (int256[] memory) { |
| 49 | return vm.parseTomlIntArray(toml, key); |
| 50 | } |
| 51 | |
| 52 | function readBytes32(string memory toml, string memory key) internal pure returns (bytes32) { |
| 53 | return vm.parseTomlBytes32(toml, key); |
| 54 | } |
| 55 | |
| 56 | function readBytes32Array(string memory toml, string memory key) internal pure returns (bytes32[] memory) { |
| 57 | return vm.parseTomlBytes32Array(toml, key); |
| 58 | } |
| 59 | |
| 60 | function readString(string memory toml, string memory key) internal pure returns (string memory) { |
| 61 | return vm.parseTomlString(toml, key); |
| 62 | } |
| 63 | |
| 64 | function readStringArray(string memory toml, string memory key) internal pure returns (string[] memory) { |
| 65 | return vm.parseTomlStringArray(toml, key); |
| 66 | } |
| 67 | |
| 68 | function readAddress(string memory toml, string memory key) internal pure returns (address) { |
| 69 | return vm.parseTomlAddress(toml, key); |
| 70 | } |
| 71 | |
| 72 | function readAddressArray(string memory toml, string memory key) internal pure returns (address[] memory) { |
| 73 | return vm.parseTomlAddressArray(toml, key); |
| 74 | } |
| 75 | |
| 76 | function readBool(string memory toml, string memory key) internal pure returns (bool) { |
| 77 | return vm.parseTomlBool(toml, key); |
| 78 | } |
| 79 | |
| 80 | function readBoolArray(string memory toml, string memory key) internal pure returns (bool[] memory) { |
| 81 | return vm.parseTomlBoolArray(toml, key); |
| 82 | } |
| 83 | |
| 84 | function readBytes(string memory toml, string memory key) internal pure returns (bytes memory) { |
| 85 | return vm.parseTomlBytes(toml, key); |
| 86 | } |
| 87 | |
| 88 | function readBytesArray(string memory toml, string memory key) internal pure returns (bytes[] memory) { |
| 89 | return vm.parseTomlBytesArray(toml, key); |
| 90 | } |
| 91 | |
| 92 | function readUintOr(string memory toml, string memory key, uint256 defaultValue) internal view returns (uint256) { |
| 93 | return keyExists(toml, key) ? readUint(toml, key) : defaultValue; |
| 94 | } |
| 95 | |
| 96 | function readUintArrayOr(string memory toml, string memory key, uint256[] memory defaultValue) |
| 97 | internal |
| 98 | view |
| 99 | returns (uint256[] memory) |
| 100 | { |
| 101 | return keyExists(toml, key) ? readUintArray(toml, key) : defaultValue; |
| 102 | } |
| 103 | |
| 104 | function readIntOr(string memory toml, string memory key, int256 defaultValue) internal view returns (int256) { |
| 105 | return keyExists(toml, key) ? readInt(toml, key) : defaultValue; |
| 106 | } |
| 107 | |
| 108 | function readIntArrayOr(string memory toml, string memory key, int256[] memory defaultValue) |
| 109 | internal |
| 110 | view |
| 111 | returns (int256[] memory) |
| 112 | { |
| 113 | return keyExists(toml, key) ? readIntArray(toml, key) : defaultValue; |
| 114 | } |
| 115 | |
| 116 | function readBytes32Or(string memory toml, string memory key, bytes32 defaultValue) |
| 117 | internal |
| 118 | view |
| 119 | returns (bytes32) |
| 120 | { |
| 121 | return keyExists(toml, key) ? readBytes32(toml, key) : defaultValue; |
| 122 | } |
| 123 | |
| 124 | function readBytes32ArrayOr(string memory toml, string memory key, bytes32[] memory defaultValue) |
| 125 | internal |
| 126 | view |
| 127 | returns (bytes32[] memory) |
| 128 | { |
| 129 | return keyExists(toml, key) ? readBytes32Array(toml, key) : defaultValue; |
| 130 | } |
| 131 | |
| 132 | function readStringOr(string memory toml, string memory key, string memory defaultValue) |
| 133 | internal |
| 134 | view |
| 135 | returns (string memory) |
| 136 | { |
| 137 | return keyExists(toml, key) ? readString(toml, key) : defaultValue; |
| 138 | } |
| 139 | |
| 140 | function readStringArrayOr(string memory toml, string memory key, string[] memory defaultValue) |
| 141 | internal |
| 142 | view |
| 143 | returns (string[] memory) |
| 144 | { |
| 145 | return keyExists(toml, key) ? readStringArray(toml, key) : defaultValue; |
| 146 | } |
| 147 | |
| 148 | function readAddressOr(string memory toml, string memory key, address defaultValue) |
| 149 | internal |
| 150 | view |
| 151 | returns (address) |
| 152 | { |
| 153 | return keyExists(toml, key) ? readAddress(toml, key) : defaultValue; |
| 154 | } |
| 155 | |
| 156 | function readAddressArrayOr(string memory toml, string memory key, address[] memory defaultValue) |
| 157 | internal |
| 158 | view |
| 159 | returns (address[] memory) |
| 160 | { |
| 161 | return keyExists(toml, key) ? readAddressArray(toml, key) : defaultValue; |
| 162 | } |
| 163 | |
| 164 | function readBoolOr(string memory toml, string memory key, bool defaultValue) internal view returns (bool) { |
| 165 | return keyExists(toml, key) ? readBool(toml, key) : defaultValue; |
| 166 | } |
| 167 | |
| 168 | function readBoolArrayOr(string memory toml, string memory key, bool[] memory defaultValue) |
| 169 | internal |
| 170 | view |
| 171 | returns (bool[] memory) |
| 172 | { |
| 173 | return keyExists(toml, key) ? readBoolArray(toml, key) : defaultValue; |
| 174 | } |
| 175 | |
| 176 | function readBytesOr(string memory toml, string memory key, bytes memory defaultValue) |
| 177 | internal |
| 178 | view |
| 179 | returns (bytes memory) |
| 180 | { |
| 181 | return keyExists(toml, key) ? readBytes(toml, key) : defaultValue; |
| 182 | } |
| 183 | |
| 184 | function readBytesArrayOr(string memory toml, string memory key, bytes[] memory defaultValue) |
| 185 | internal |
| 186 | view |
| 187 | returns (bytes[] memory) |
| 188 | { |
| 189 | return keyExists(toml, key) ? readBytesArray(toml, key) : defaultValue; |
| 190 | } |
| 191 | |
| 192 | function serialize(string memory jsonKey, string memory rootObject) internal returns (string memory) { |
| 193 | return vm.serializeJson(jsonKey, rootObject); |
| 194 | } |
| 195 | |
| 196 | function serialize(string memory jsonKey, string memory key, bool value) internal returns (string memory) { |
| 197 | return vm.serializeBool(jsonKey, key, value); |
| 198 | } |
| 199 | |
| 200 | function serialize(string memory jsonKey, string memory key, bool[] memory value) internal returns (string memory) { |
| 201 | return vm.serializeBool(jsonKey, key, value); |
| 202 | } |
| 203 | |
| 204 | function serialize(string memory jsonKey, string memory key, uint256 value) internal returns (string memory) { |
| 205 | return vm.serializeUint(jsonKey, key, value); |
| 206 | } |
| 207 | |
| 208 | function serialize(string memory jsonKey, string memory key, uint256[] memory value) |
| 209 | internal |
| 210 | returns (string memory) |
| 211 | { |
| 212 | return vm.serializeUint(jsonKey, key, value); |
| 213 | } |
| 214 | |
| 215 | function serialize(string memory jsonKey, string memory key, int256 value) internal returns (string memory) { |
| 216 | return vm.serializeInt(jsonKey, key, value); |
| 217 | } |
| 218 | |
| 219 | function serialize(string memory jsonKey, string memory key, int256[] memory value) |
| 220 | internal |
| 221 | returns (string memory) |
| 222 | { |
| 223 | return vm.serializeInt(jsonKey, key, value); |
| 224 | } |
| 225 | |
| 226 | function serialize(string memory jsonKey, string memory key, address value) internal returns (string memory) { |
| 227 | return vm.serializeAddress(jsonKey, key, value); |
| 228 | } |
| 229 | |
| 230 | function serialize(string memory jsonKey, string memory key, address[] memory value) |
| 231 | internal |
| 232 | returns (string memory) |
| 233 | { |
| 234 | return vm.serializeAddress(jsonKey, key, value); |
| 235 | } |
| 236 | |
| 237 | function serialize(string memory jsonKey, string memory key, bytes32 value) internal returns (string memory) { |
| 238 | return vm.serializeBytes32(jsonKey, key, value); |
| 239 | } |
| 240 | |
| 241 | function serialize(string memory jsonKey, string memory key, bytes32[] memory value) |
| 242 | internal |
| 243 | returns (string memory) |
| 244 | { |
| 245 | return vm.serializeBytes32(jsonKey, key, value); |
| 246 | } |
| 247 | |
| 248 | function serialize(string memory jsonKey, string memory key, bytes memory value) internal returns (string memory) { |
| 249 | return vm.serializeBytes(jsonKey, key, value); |
| 250 | } |
| 251 | |
| 252 | function serialize(string memory jsonKey, string memory key, bytes[] memory value) |
| 253 | internal |
| 254 | returns (string memory) |
| 255 | { |
| 256 | return vm.serializeBytes(jsonKey, key, value); |
| 257 | } |
| 258 | |
| 259 | function serialize(string memory jsonKey, string memory key, string memory value) internal returns (string memory) { |
| 260 | return vm.serializeString(jsonKey, key, value); |
| 261 | } |
| 262 | |
| 263 | function serialize(string memory jsonKey, string memory key, string[] memory value) |
| 264 | internal |
| 265 | returns (string memory) |
| 266 | { |
| 267 | return vm.serializeString(jsonKey, key, value); |
| 268 | } |
| 269 | |
| 270 | function write(string memory jsonKey, string memory path) internal { |
| 271 | vm.writeToml(jsonKey, path); |
| 272 | } |
| 273 | |
| 274 | function write(string memory jsonKey, string memory path, string memory valueKey) internal { |
| 275 | vm.writeToml(jsonKey, path, valueKey); |
| 276 | } |
| 277 | } |
| 278 |
0.0%
lib/forge-std/src/StdUtils.sol
Lines covered: 0 / 21 (0.0%)
| 1 | // SPDX-License-Identifier: MIT |
| 2 | pragma solidity >=0.6.2 <0.9.0; |
| 3 | |
| 4 | pragma experimental ABIEncoderV2; |
| 5 | |
| 6 | import {IMulticall3} from "./interfaces/IMulticall3.sol"; |
| 7 | import {VmSafe} from "./Vm.sol"; |
| 8 | |
| 9 | abstract contract StdUtils { |
| 10 | /*////////////////////////////////////////////////////////////////////////// |
| 11 | CONSTANTS |
| 12 | //////////////////////////////////////////////////////////////////////////*/ |
| 13 | |
| 14 | IMulticall3 private constant multicall = IMulticall3(0xcA11bde05977b3631167028862bE2a173976CA11); |
| 15 | VmSafe private constant vm = VmSafe(address(uint160(uint256(keccak256("hevm cheat code"))))); |
| 16 | address private constant CONSOLE2_ADDRESS = 0x000000000000000000636F6e736F6c652e6c6f67; |
| 17 | uint256 private constant INT256_MIN_ABS = |
| 18 | 57896044618658097711785492504343953926634992332820282019728792003956564819968; |
| 19 | uint256 private constant SECP256K1_ORDER = |
| 20 | 115792089237316195423570985008687907852837564279074904382605163141518161494337; |
| 21 | uint256 private constant UINT256_MAX = |
| 22 | 115792089237316195423570985008687907853269984665640564039457584007913129639935; |
| 23 | |
| 24 | // Used by default when deploying with create2, https://github.com/Arachnid/deterministic-deployment-proxy. |
| 25 | address private constant CREATE2_FACTORY = 0x4e59b44847b379578588920cA78FbF26c0B4956C; |
| 26 | |
| 27 | /*////////////////////////////////////////////////////////////////////////// |
| 28 | INTERNAL FUNCTIONS |
| 29 | //////////////////////////////////////////////////////////////////////////*/ |
| 30 | |
| 31 | function _bound(uint256 x, uint256 min, uint256 max) internal pure virtual returns (uint256 result) { |
| 32 | require(min <= max, "StdUtils bound(uint256,uint256,uint256): Max is less than min."); |
| 33 | // If x is between min and max, return x directly. This is to ensure that dictionary values |
| 34 | // do not get shifted if the min is nonzero. More info: https://github.com/foundry-rs/forge-std/issues/188 |
| 35 | if (x >= min && x <= max) return x; |
| 36 | |
| 37 | uint256 size = max - min + 1; |
| 38 | |
| 39 | // If the value is 0, 1, 2, 3, wrap that to min, min+1, min+2, min+3. Similarly for the UINT256_MAX side. |
| 40 | // This helps ensure coverage of the min/max values. |
| 41 | if (x <= 3 && size > x) return min + x; |
| 42 | if (x >= UINT256_MAX - 3 && size > UINT256_MAX - x) return max - (UINT256_MAX - x); |
| 43 | |
| 44 | // Otherwise, wrap x into the range [min, max], i.e. the range is inclusive. |
| 45 | if (x > max) { |
| 46 | uint256 diff = x - max; |
| 47 | uint256 rem = diff % size; |
| 48 | if (rem == 0) return max; |
| 49 | result = min + rem - 1; |
| 50 | } else if (x < min) { |
| 51 | uint256 diff = min - x; |
| 52 | uint256 rem = diff % size; |
| 53 | if (rem == 0) return min; |
| 54 | result = max - rem + 1; |
| 55 | } |
| 56 | } |
| 57 | |
| 58 | function bound(uint256 x, uint256 min, uint256 max) internal pure virtual returns (uint256 result) { |
| 59 | result = _bound(x, min, max); |
| 60 | console2_log_StdUtils("Bound result", result); |
| 61 | } |
| 62 | |
| 63 | function _bound(int256 x, int256 min, int256 max) internal pure virtual returns (int256 result) { |
| 64 | require(min <= max, "StdUtils bound(int256,int256,int256): Max is less than min."); |
| 65 | |
| 66 | // Shifting all int256 values to uint256 to use _bound function. The range of two types are: |
| 67 | // int256 : -(2**255) ~ (2**255 - 1) |
| 68 | // uint256: 0 ~ (2**256 - 1) |
| 69 | // So, add 2**255, INT256_MIN_ABS to the integer values. |
| 70 | // |
| 71 | // If the given integer value is -2**255, we cannot use `-uint256(-x)` because of the overflow. |
| 72 | // So, use `~uint256(x) + 1` instead. |
| 73 | uint256 _x = x < 0 ? (INT256_MIN_ABS - ~uint256(x) - 1) : (uint256(x) + INT256_MIN_ABS); |
| 74 | uint256 _min = min < 0 ? (INT256_MIN_ABS - ~uint256(min) - 1) : (uint256(min) + INT256_MIN_ABS); |
| 75 | uint256 _max = max < 0 ? (INT256_MIN_ABS - ~uint256(max) - 1) : (uint256(max) + INT256_MIN_ABS); |
| 76 | |
| 77 | uint256 y = _bound(_x, _min, _max); |
| 78 | |
| 79 | // To move it back to int256 value, subtract INT256_MIN_ABS at here. |
| 80 | result = y < INT256_MIN_ABS ? int256(~(INT256_MIN_ABS - y) + 1) : int256(y - INT256_MIN_ABS); |
| 81 | } |
| 82 | |
| 83 | function bound(int256 x, int256 min, int256 max) internal pure virtual returns (int256 result) { |
| 84 | result = _bound(x, min, max); |
| 85 | console2_log_StdUtils("Bound result", vm.toString(result)); |
| 86 | } |
| 87 | |
| 88 | function boundPrivateKey(uint256 privateKey) internal pure virtual returns (uint256 result) { |
| 89 | result = _bound(privateKey, 1, SECP256K1_ORDER - 1); |
| 90 | } |
| 91 | |
| 92 | function bytesToUint(bytes memory b) internal pure virtual returns (uint256) { |
| 93 | require(b.length <= 32, "StdUtils bytesToUint(bytes): Bytes length exceeds 32."); |
| 94 | return abi.decode(abi.encodePacked(new bytes(32 - b.length), b), (uint256)); |
| 95 | } |
| 96 | |
| 97 | /// @dev Compute the address a contract will be deployed at for a given deployer address and nonce |
| 98 | function computeCreateAddress(address deployer, uint256 nonce) internal pure virtual returns (address) { |
| 99 | console2_log_StdUtils("computeCreateAddress is deprecated. Please use vm.computeCreateAddress instead."); |
| 100 | return vm.computeCreateAddress(deployer, nonce); |
| 101 | } |
| 102 | |
| 103 | function computeCreate2Address(bytes32 salt, bytes32 initcodeHash, address deployer) |
| 104 | internal |
| 105 | pure |
| 106 | virtual |
| 107 | returns (address) |
| 108 | { |
| 109 | console2_log_StdUtils("computeCreate2Address is deprecated. Please use vm.computeCreate2Address instead."); |
| 110 | return vm.computeCreate2Address(salt, initcodeHash, deployer); |
| 111 | } |
| 112 | |
| 113 | /// @dev returns the address of a contract created with CREATE2 using the default CREATE2 deployer |
| 114 | function computeCreate2Address(bytes32 salt, bytes32 initCodeHash) internal pure returns (address) { |
| 115 | console2_log_StdUtils("computeCreate2Address is deprecated. Please use vm.computeCreate2Address instead."); |
| 116 | return vm.computeCreate2Address(salt, initCodeHash); |
| 117 | } |
| 118 | |
| 119 | /// @dev returns the hash of the init code (creation code + no args) used in CREATE2 with no constructor arguments |
| 120 | /// @param creationCode the creation code of a contract C, as returned by type(C).creationCode |
| 121 | function hashInitCode(bytes memory creationCode) internal pure returns (bytes32) { |
| 122 | return hashInitCode(creationCode, ""); |
| 123 | } |
| 124 | |
| 125 | /// @dev returns the hash of the init code (creation code + ABI-encoded args) used in CREATE2 |
| 126 | /// @param creationCode the creation code of a contract C, as returned by type(C).creationCode |
| 127 | /// @param args the ABI-encoded arguments to the constructor of C |
| 128 | function hashInitCode(bytes memory creationCode, bytes memory args) internal pure returns (bytes32) { |
| 129 | return keccak256(abi.encodePacked(creationCode, args)); |
| 130 | } |
| 131 | |
| 132 | // Performs a single call with Multicall3 to query the ERC-20 token balances of the given addresses. |
| 133 | function getTokenBalances(address token, address[] memory addresses) |
| 134 | internal |
| 135 | virtual |
| 136 | returns (uint256[] memory balances) |
| 137 | { |
| 138 | uint256 tokenCodeSize; |
| 139 | assembly { |
| 140 | tokenCodeSize := extcodesize(token) |
| 141 | } |
| 142 | require(tokenCodeSize > 0, "StdUtils getTokenBalances(address,address[]): Token address is not a contract."); |
| 143 | |
| 144 | // ABI encode the aggregate call to Multicall3. |
| 145 | uint256 length = addresses.length; |
| 146 | IMulticall3.Call[] memory calls = new IMulticall3.Call[](length); |
| 147 | for (uint256 i = 0; i < length; ++i) { |
| 148 | // 0x70a08231 = bytes4("balanceOf(address)")) |
| 149 | calls[i] = IMulticall3.Call({target: token, callData: abi.encodeWithSelector(0x70a08231, (addresses[i]))}); |
| 150 | } |
| 151 | |
| 152 | // Make the aggregate call. |
| 153 | (, bytes[] memory returnData) = multicall.aggregate(calls); |
| 154 | |
| 155 | // ABI decode the return data and return the balances. |
| 156 | balances = new uint256[](length); |
| 157 | for (uint256 i = 0; i < length; ++i) { |
| 158 | balances[i] = abi.decode(returnData[i], (uint256)); |
| 159 | } |
| 160 | } |
| 161 | |
| 162 | /*////////////////////////////////////////////////////////////////////////// |
| 163 | PRIVATE FUNCTIONS |
| 164 | //////////////////////////////////////////////////////////////////////////*/ |
| 165 | |
| 166 | function addressFromLast20Bytes(bytes32 bytesValue) private pure returns (address) { |
| 167 | return address(uint160(uint256(bytesValue))); |
| 168 | } |
| 169 | |
| 170 | // This section is used to prevent the compilation of console, which shortens the compilation time when console is |
| 171 | // not used elsewhere. We also trick the compiler into letting us make the console log methods as `pure` to avoid |
| 172 | // any breaking changes to function signatures. |
| 173 | function _castLogPayloadViewToPure(function(bytes memory) internal view fnIn) |
| 174 | internal |
| 175 | pure |
| 176 | returns (function(bytes memory) internal pure fnOut) |
| 177 | { |
| 178 | assembly { |
| 179 | fnOut := fnIn |
| 180 | } |
| 181 | } |
| 182 | |
| 183 | function _sendLogPayload(bytes memory payload) internal pure { |
| 184 | _castLogPayloadViewToPure(_sendLogPayloadView)(payload); |
| 185 | } |
| 186 | |
| 187 | function _sendLogPayloadView(bytes memory payload) private view { |
| 188 | uint256 payloadLength = payload.length; |
| 189 | address consoleAddress = CONSOLE2_ADDRESS; |
| 190 | /// @solidity memory-safe-assembly |
| 191 | assembly { |
| 192 | let payloadStart := add(payload, 32) |
| 193 | let r := staticcall(gas(), consoleAddress, payloadStart, payloadLength, 0, 0) |
| 194 | } |
| 195 | } |
| 196 | |
| 197 | function console2_log_StdUtils(string memory p0) private pure { |
| 198 | _sendLogPayload(abi.encodeWithSignature("log(string)", p0)); |
| 199 | } |
| 200 | |
| 201 | function console2_log_StdUtils(string memory p0, uint256 p1) private pure { |
| 202 | _sendLogPayload(abi.encodeWithSignature("log(string,uint256)", p0, p1)); |
| 203 | } |
| 204 | |
| 205 | function console2_log_StdUtils(string memory p0, string memory p1) private pure { |
| 206 | _sendLogPayload(abi.encodeWithSignature("log(string,string)", p0, p1)); |
| 207 | } |
| 208 | } |
| 209 |
100.0%
lib/forge-std/src/Test.sol
Lines covered: 1 / 1 (100.0%)
| 1 | // SPDX-License-Identifier: MIT |
| 2 | pragma solidity >=0.6.2 <0.9.0; |
| 3 | |
| 4 | pragma experimental ABIEncoderV2; |
| 5 | |
| 6 | // 💬 ABOUT |
| 7 | // Forge Std's default Test. |
| 8 | |
| 9 | // 🧩 MODULES |
| 10 | import {console} from "./console.sol"; |
| 11 | import {console2} from "./console2.sol"; |
| 12 | import {safeconsole} from "./safeconsole.sol"; |
| 13 | import {StdAssertions} from "./StdAssertions.sol"; |
| 14 | import {StdChains} from "./StdChains.sol"; |
| 15 | import {StdCheats} from "./StdCheats.sol"; |
| 16 | import {StdConstants} from "./StdConstants.sol"; |
| 17 | import {stdError} from "./StdError.sol"; |
| 18 | import {StdInvariant} from "./StdInvariant.sol"; |
| 19 | import {stdJson} from "./StdJson.sol"; |
| 20 | import {stdMath} from "./StdMath.sol"; |
| 21 | import {StdStorage, stdStorage} from "./StdStorage.sol"; |
| 22 | import {StdStyle} from "./StdStyle.sol"; |
| 23 | import {stdToml} from "./StdToml.sol"; |
| 24 | import {StdUtils} from "./StdUtils.sol"; |
| 25 | import {Vm} from "./Vm.sol"; |
| 26 | |
| 27 | // 📦 BOILERPLATE |
| 28 | import {TestBase} from "./Base.sol"; |
| 29 | |
| 30 | // ⭐️ TEST |
| 31 | abstract contract Test is TestBase, StdAssertions, StdChains, StdCheats, StdInvariant, StdUtils { |
| 32 | // Note: IS_TEST() must return true. |
| 33 | bool public IS_TEST = true; |
| 34 | } |
| 35 |
0.0%
lib/forge-std/src/Vm.sol
Lines covered: 0 / 0 (0.0%)
| 1 | // Automatically @generated by scripts/vm.py. Do not modify manually. |
| 2 | |
| 3 | // SPDX-License-Identifier: MIT OR Apache-2.0 |
| 4 | pragma solidity >=0.6.2 <0.9.0; |
| 5 | pragma experimental ABIEncoderV2; |
| 6 | |
| 7 | /// The `VmSafe` interface does not allow manipulation of the EVM state or other actions that may |
| 8 | /// result in Script simulations differing from on-chain execution. It is recommended to only use |
| 9 | /// these cheats in scripts. |
| 10 | interface VmSafe { |
| 11 | /// A modification applied to either `msg.sender` or `tx.origin`. Returned by `readCallers`. |
| 12 | enum CallerMode { |
| 13 | // No caller modification is currently active. |
| 14 | None, |
| 15 | // A one time broadcast triggered by a `vm.broadcast()` call is currently active. |
| 16 | Broadcast, |
| 17 | // A recurrent broadcast triggered by a `vm.startBroadcast()` call is currently active. |
| 18 | RecurrentBroadcast, |
| 19 | // A one time prank triggered by a `vm.prank()` call is currently active. |
| 20 | Prank, |
| 21 | // A recurrent prank triggered by a `vm.startPrank()` call is currently active. |
| 22 | RecurrentPrank |
| 23 | } |
| 24 | |
| 25 | /// The kind of account access that occurred. |
| 26 | enum AccountAccessKind { |
| 27 | // The account was called. |
| 28 | Call, |
| 29 | // The account was called via delegatecall. |
| 30 | DelegateCall, |
| 31 | // The account was called via callcode. |
| 32 | CallCode, |
| 33 | // The account was called via staticcall. |
| 34 | StaticCall, |
| 35 | // The account was created. |
| 36 | Create, |
| 37 | // The account was selfdestructed. |
| 38 | SelfDestruct, |
| 39 | // Synthetic access indicating the current context has resumed after a previous sub-context (AccountAccess). |
| 40 | Resume, |
| 41 | // The account's balance was read. |
| 42 | Balance, |
| 43 | // The account's codesize was read. |
| 44 | Extcodesize, |
| 45 | // The account's codehash was read. |
| 46 | Extcodehash, |
| 47 | // The account's code was copied. |
| 48 | Extcodecopy |
| 49 | } |
| 50 | |
| 51 | /// Forge execution contexts. |
| 52 | enum ForgeContext { |
| 53 | // Test group execution context (test, coverage or snapshot). |
| 54 | TestGroup, |
| 55 | // `forge test` execution context. |
| 56 | Test, |
| 57 | // `forge coverage` execution context. |
| 58 | Coverage, |
| 59 | // `forge snapshot` execution context. |
| 60 | Snapshot, |
| 61 | // Script group execution context (dry run, broadcast or resume). |
| 62 | ScriptGroup, |
| 63 | // `forge script` execution context. |
| 64 | ScriptDryRun, |
| 65 | // `forge script --broadcast` execution context. |
| 66 | ScriptBroadcast, |
| 67 | // `forge script --resume` execution context. |
| 68 | ScriptResume, |
| 69 | // Unknown `forge` execution context. |
| 70 | Unknown |
| 71 | } |
| 72 | |
| 73 | /// The transaction type (`txType`) of the broadcast. |
| 74 | enum BroadcastTxType { |
| 75 | // Represents a CALL broadcast tx. |
| 76 | Call, |
| 77 | // Represents a CREATE broadcast tx. |
| 78 | Create, |
| 79 | // Represents a CREATE2 broadcast tx. |
| 80 | Create2 |
| 81 | } |
| 82 | |
| 83 | /// An Ethereum log. Returned by `getRecordedLogs`. |
| 84 | struct Log { |
| 85 | // The topics of the log, including the signature, if any. |
| 86 | bytes32[] topics; |
| 87 | // The raw data of the log. |
| 88 | bytes data; |
| 89 | // The address of the log's emitter. |
| 90 | address emitter; |
| 91 | } |
| 92 | |
| 93 | /// An RPC URL and its alias. Returned by `rpcUrlStructs`. |
| 94 | struct Rpc { |
| 95 | // The alias of the RPC URL. |
| 96 | string key; |
| 97 | // The RPC URL. |
| 98 | string url; |
| 99 | } |
| 100 | |
| 101 | /// An RPC log object. Returned by `eth_getLogs`. |
| 102 | struct EthGetLogs { |
| 103 | // The address of the log's emitter. |
| 104 | address emitter; |
| 105 | // The topics of the log, including the signature, if any. |
| 106 | bytes32[] topics; |
| 107 | // The raw data of the log. |
| 108 | bytes data; |
| 109 | // The block hash. |
| 110 | bytes32 blockHash; |
| 111 | // The block number. |
| 112 | uint64 blockNumber; |
| 113 | // The transaction hash. |
| 114 | bytes32 transactionHash; |
| 115 | // The transaction index in the block. |
| 116 | uint64 transactionIndex; |
| 117 | // The log index. |
| 118 | uint256 logIndex; |
| 119 | // Whether the log was removed. |
| 120 | bool removed; |
| 121 | } |
| 122 | |
| 123 | /// A single entry in a directory listing. Returned by `readDir`. |
| 124 | struct DirEntry { |
| 125 | // The error message, if any. |
| 126 | string errorMessage; |
| 127 | // The path of the entry. |
| 128 | string path; |
| 129 | // The depth of the entry. |
| 130 | uint64 depth; |
| 131 | // Whether the entry is a directory. |
| 132 | bool isDir; |
| 133 | // Whether the entry is a symlink. |
| 134 | bool isSymlink; |
| 135 | } |
| 136 | |
| 137 | /// Metadata information about a file. |
| 138 | /// This structure is returned from the `fsMetadata` function and represents known |
| 139 | /// metadata about a file such as its permissions, size, modification |
| 140 | /// times, etc. |
| 141 | struct FsMetadata { |
| 142 | // True if this metadata is for a directory. |
| 143 | bool isDir; |
| 144 | // True if this metadata is for a symlink. |
| 145 | bool isSymlink; |
| 146 | // The size of the file, in bytes, this metadata is for. |
| 147 | uint256 length; |
| 148 | // True if this metadata is for a readonly (unwritable) file. |
| 149 | bool readOnly; |
| 150 | // The last modification time listed in this metadata. |
| 151 | uint256 modified; |
| 152 | // The last access time of this metadata. |
| 153 | uint256 accessed; |
| 154 | // The creation time listed in this metadata. |
| 155 | uint256 created; |
| 156 | } |
| 157 | |
| 158 | /// A wallet with a public and private key. |
| 159 | struct Wallet { |
| 160 | // The wallet's address. |
| 161 | address addr; |
| 162 | // The wallet's public key `X`. |
| 163 | uint256 publicKeyX; |
| 164 | // The wallet's public key `Y`. |
| 165 | uint256 publicKeyY; |
| 166 | // The wallet's private key. |
| 167 | uint256 privateKey; |
| 168 | } |
| 169 | |
| 170 | /// The result of a `tryFfi` call. |
| 171 | struct FfiResult { |
| 172 | // The exit code of the call. |
| 173 | int32 exitCode; |
| 174 | // The optionally hex-decoded `stdout` data. |
| 175 | bytes stdout; |
| 176 | // The `stderr` data. |
| 177 | bytes stderr; |
| 178 | } |
| 179 | |
| 180 | /// Information on the chain and fork. |
| 181 | struct ChainInfo { |
| 182 | // The fork identifier. Set to zero if no fork is active. |
| 183 | uint256 forkId; |
| 184 | // The chain ID of the current fork. |
| 185 | uint256 chainId; |
| 186 | } |
| 187 | |
| 188 | /// Information about a blockchain. |
| 189 | struct Chain { |
| 190 | // The chain name. |
| 191 | string name; |
| 192 | // The chain's Chain ID. |
| 193 | uint256 chainId; |
| 194 | // The chain's alias. (i.e. what gets specified in `foundry.toml`). |
| 195 | string chainAlias; |
| 196 | // A default RPC endpoint for this chain. |
| 197 | string rpcUrl; |
| 198 | } |
| 199 | |
| 200 | /// The result of a `stopAndReturnStateDiff` call. |
| 201 | struct AccountAccess { |
| 202 | // The chain and fork the access occurred. |
| 203 | ChainInfo chainInfo; |
| 204 | // The kind of account access that determines what the account is. |
| 205 | // If kind is Call, DelegateCall, StaticCall or CallCode, then the account is the callee. |
| 206 | // If kind is Create, then the account is the newly created account. |
| 207 | // If kind is SelfDestruct, then the account is the selfdestruct recipient. |
| 208 | // If kind is a Resume, then account represents a account context that has resumed. |
| 209 | AccountAccessKind kind; |
| 210 | // The account that was accessed. |
| 211 | // It's either the account created, callee or a selfdestruct recipient for CREATE, CALL or SELFDESTRUCT. |
| 212 | address account; |
| 213 | // What accessed the account. |
| 214 | address accessor; |
| 215 | // If the account was initialized or empty prior to the access. |
| 216 | // An account is considered initialized if it has code, a |
| 217 | // non-zero nonce, or a non-zero balance. |
| 218 | bool initialized; |
| 219 | // The previous balance of the accessed account. |
| 220 | uint256 oldBalance; |
| 221 | // The potential new balance of the accessed account. |
| 222 | // That is, all balance changes are recorded here, even if reverts occurred. |
| 223 | uint256 newBalance; |
| 224 | // Code of the account deployed by CREATE. |
| 225 | bytes deployedCode; |
| 226 | // Value passed along with the account access |
| 227 | uint256 value; |
| 228 | // Input data provided to the CREATE or CALL |
| 229 | bytes data; |
| 230 | // If this access reverted in either the current or parent context. |
| 231 | bool reverted; |
| 232 | // An ordered list of storage accesses made during an account access operation. |
| 233 | StorageAccess[] storageAccesses; |
| 234 | // Call depth traversed during the recording of state differences |
| 235 | uint64 depth; |
| 236 | // The previous nonce of the accessed account. |
| 237 | uint64 oldNonce; |
| 238 | // The new nonce of the accessed account. |
| 239 | uint64 newNonce; |
| 240 | } |
| 241 | |
| 242 | /// The storage accessed during an `AccountAccess`. |
| 243 | struct StorageAccess { |
| 244 | // The account whose storage was accessed. |
| 245 | address account; |
| 246 | // The slot that was accessed. |
| 247 | bytes32 slot; |
| 248 | // If the access was a write. |
| 249 | bool isWrite; |
| 250 | // The previous value of the slot. |
| 251 | bytes32 previousValue; |
| 252 | // The new value of the slot. |
| 253 | bytes32 newValue; |
| 254 | // If the access was reverted. |
| 255 | bool reverted; |
| 256 | } |
| 257 | |
| 258 | /// Gas used. Returned by `lastCallGas`. |
| 259 | struct Gas { |
| 260 | // The gas limit of the call. |
| 261 | uint64 gasLimit; |
| 262 | // The total gas used. |
| 263 | uint64 gasTotalUsed; |
| 264 | // DEPRECATED: The amount of gas used for memory expansion. Ref: <https://github.com/foundry-rs/foundry/pull/7934#pullrequestreview-2069236939> |
| 265 | uint64 gasMemoryUsed; |
| 266 | // The amount of gas refunded. |
| 267 | int64 gasRefunded; |
| 268 | // The amount of gas remaining. |
| 269 | uint64 gasRemaining; |
| 270 | } |
| 271 | |
| 272 | /// The result of the `stopDebugTraceRecording` call |
| 273 | struct DebugStep { |
| 274 | // The stack before executing the step of the run. |
| 275 | // stack\[0\] represents the top of the stack. |
| 276 | // and only stack data relevant to the opcode execution is contained. |
| 277 | uint256[] stack; |
| 278 | // The memory input data before executing the step of the run. |
| 279 | // only input data relevant to the opcode execution is contained. |
| 280 | // e.g. for MLOAD, it will have memory\[offset:offset+32\] copied here. |
| 281 | // the offset value can be get by the stack data. |
| 282 | bytes memoryInput; |
| 283 | // The opcode that was accessed. |
| 284 | uint8 opcode; |
| 285 | // The call depth of the step. |
| 286 | uint64 depth; |
| 287 | // Whether the call end up with out of gas error. |
| 288 | bool isOutOfGas; |
| 289 | // The contract address where the opcode is running |
| 290 | address contractAddr; |
| 291 | } |
| 292 | |
| 293 | /// Represents a transaction's broadcast details. |
| 294 | struct BroadcastTxSummary { |
| 295 | // The hash of the transaction that was broadcasted |
| 296 | bytes32 txHash; |
| 297 | // Represent the type of transaction among CALL, CREATE, CREATE2 |
| 298 | BroadcastTxType txType; |
| 299 | // The address of the contract that was called or created. |
| 300 | // This is address of the contract that is created if the txType is CREATE or CREATE2. |
| 301 | address contractAddress; |
| 302 | // The block number the transaction landed in. |
| 303 | uint64 blockNumber; |
| 304 | // Status of the transaction, retrieved from the transaction receipt. |
| 305 | bool success; |
| 306 | } |
| 307 | |
| 308 | /// Holds a signed EIP-7702 authorization for an authority account to delegate to an implementation. |
| 309 | struct SignedDelegation { |
| 310 | // The y-parity of the recovered secp256k1 signature (0 or 1). |
| 311 | uint8 v; |
| 312 | // First 32 bytes of the signature. |
| 313 | bytes32 r; |
| 314 | // Second 32 bytes of the signature. |
| 315 | bytes32 s; |
| 316 | // The current nonce of the authority account at signing time. |
| 317 | // Used to ensure signature can't be replayed after account nonce changes. |
| 318 | uint64 nonce; |
| 319 | // Address of the contract implementation that will be delegated to. |
| 320 | // Gets encoded into delegation code: 0xef0100 || implementation. |
| 321 | address implementation; |
| 322 | } |
| 323 | |
| 324 | /// Represents a "potential" revert reason from a single subsequent call when using `vm.assumeNoReverts`. |
| 325 | /// Reverts that match will result in a FOUNDRY::ASSUME rejection, whereas unmatched reverts will be surfaced |
| 326 | /// as normal. |
| 327 | struct PotentialRevert { |
| 328 | // The allowed origin of the revert opcode; address(0) allows reverts from any address |
| 329 | address reverter; |
| 330 | // When true, only matches on the beginning of the revert data, otherwise, matches on entire revert data |
| 331 | bool partialMatch; |
| 332 | // The data to use to match encountered reverts |
| 333 | bytes revertData; |
| 334 | } |
| 335 | |
| 336 | /// An EIP-2930 access list item. |
| 337 | struct AccessListItem { |
| 338 | // The address to be added in access list. |
| 339 | address target; |
| 340 | // The storage keys to be added in access list. |
| 341 | bytes32[] storageKeys; |
| 342 | } |
| 343 | |
| 344 | // ======== Crypto ======== |
| 345 | |
| 346 | /// Derives a private key from the name, labels the account with that name, and returns the wallet. |
| 347 | function createWallet(string calldata walletLabel) external returns (Wallet memory wallet); |
| 348 | |
| 349 | /// Generates a wallet from the private key and returns the wallet. |
| 350 | function createWallet(uint256 privateKey) external returns (Wallet memory wallet); |
| 351 | |
| 352 | /// Generates a wallet from the private key, labels the account with that name, and returns the wallet. |
| 353 | function createWallet(uint256 privateKey, string calldata walletLabel) external returns (Wallet memory wallet); |
| 354 | |
| 355 | /// Derive a private key from a provided mnemonic string (or mnemonic file path) |
| 356 | /// at the derivation path `m/44'/60'/0'/0/{index}`. |
| 357 | function deriveKey(string calldata mnemonic, uint32 index) external pure returns (uint256 privateKey); |
| 358 | |
| 359 | /// Derive a private key from a provided mnemonic string (or mnemonic file path) |
| 360 | /// at `{derivationPath}{index}`. |
| 361 | function deriveKey(string calldata mnemonic, string calldata derivationPath, uint32 index) |
| 362 | external |
| 363 | pure |
| 364 | returns (uint256 privateKey); |
| 365 | |
| 366 | /// Derive a private key from a provided mnemonic string (or mnemonic file path) in the specified language |
| 367 | /// at the derivation path `m/44'/60'/0'/0/{index}`. |
| 368 | function deriveKey(string calldata mnemonic, uint32 index, string calldata language) |
| 369 | external |
| 370 | pure |
| 371 | returns (uint256 privateKey); |
| 372 | |
| 373 | /// Derive a private key from a provided mnemonic string (or mnemonic file path) in the specified language |
| 374 | /// at `{derivationPath}{index}`. |
| 375 | function deriveKey(string calldata mnemonic, string calldata derivationPath, uint32 index, string calldata language) |
| 376 | external |
| 377 | pure |
| 378 | returns (uint256 privateKey); |
| 379 | |
| 380 | /// Derives secp256r1 public key from the provided `privateKey`. |
| 381 | function publicKeyP256(uint256 privateKey) external pure returns (uint256 publicKeyX, uint256 publicKeyY); |
| 382 | |
| 383 | /// Adds a private key to the local forge wallet and returns the address. |
| 384 | function rememberKey(uint256 privateKey) external returns (address keyAddr); |
| 385 | |
| 386 | /// Derive a set number of wallets from a mnemonic at the derivation path `m/44'/60'/0'/0/{0..count}`. |
| 387 | /// The respective private keys are saved to the local forge wallet for later use and their addresses are returned. |
| 388 | function rememberKeys(string calldata mnemonic, string calldata derivationPath, uint32 count) |
| 389 | external |
| 390 | returns (address[] memory keyAddrs); |
| 391 | |
| 392 | /// Derive a set number of wallets from a mnemonic in the specified language at the derivation path `m/44'/60'/0'/0/{0..count}`. |
| 393 | /// The respective private keys are saved to the local forge wallet for later use and their addresses are returned. |
| 394 | function rememberKeys( |
| 395 | string calldata mnemonic, |
| 396 | string calldata derivationPath, |
| 397 | string calldata language, |
| 398 | uint32 count |
| 399 | ) external returns (address[] memory keyAddrs); |
| 400 | |
| 401 | /// Signs data with a `Wallet`. |
| 402 | /// Returns a compact signature (`r`, `vs`) as per EIP-2098, where `vs` encodes both the |
| 403 | /// signature's `s` value, and the recovery id `v` in a single bytes32. |
| 404 | /// This format reduces the signature size from 65 to 64 bytes. |
| 405 | function signCompact(Wallet calldata wallet, bytes32 digest) external returns (bytes32 r, bytes32 vs); |
| 406 | |
| 407 | /// Signs `digest` with `privateKey` using the secp256k1 curve. |
| 408 | /// Returns a compact signature (`r`, `vs`) as per EIP-2098, where `vs` encodes both the |
| 409 | /// signature's `s` value, and the recovery id `v` in a single bytes32. |
| 410 | /// This format reduces the signature size from 65 to 64 bytes. |
| 411 | function signCompact(uint256 privateKey, bytes32 digest) external pure returns (bytes32 r, bytes32 vs); |
| 412 | |
| 413 | /// Signs `digest` with signer provided to script using the secp256k1 curve. |
| 414 | /// Returns a compact signature (`r`, `vs`) as per EIP-2098, where `vs` encodes both the |
| 415 | /// signature's `s` value, and the recovery id `v` in a single bytes32. |
| 416 | /// This format reduces the signature size from 65 to 64 bytes. |
| 417 | /// If `--sender` is provided, the signer with provided address is used, otherwise, |
| 418 | /// if exactly one signer is provided to the script, that signer is used. |
| 419 | /// Raises error if signer passed through `--sender` does not match any unlocked signers or |
| 420 | /// if `--sender` is not provided and not exactly one signer is passed to the script. |
| 421 | function signCompact(bytes32 digest) external pure returns (bytes32 r, bytes32 vs); |
| 422 | |
| 423 | /// Signs `digest` with signer provided to script using the secp256k1 curve. |
| 424 | /// Returns a compact signature (`r`, `vs`) as per EIP-2098, where `vs` encodes both the |
| 425 | /// signature's `s` value, and the recovery id `v` in a single bytes32. |
| 426 | /// This format reduces the signature size from 65 to 64 bytes. |
| 427 | /// Raises error if none of the signers passed into the script have provided address. |
| 428 | function signCompact(address signer, bytes32 digest) external pure returns (bytes32 r, bytes32 vs); |
| 429 | |
| 430 | /// Signs `digest` with `privateKey` using the secp256r1 curve. |
| 431 | function signP256(uint256 privateKey, bytes32 digest) external pure returns (bytes32 r, bytes32 s); |
| 432 | |
| 433 | /// Signs `digest` with `privateKey` on the secp256k1 curve, using the given `nonce` |
| 434 | /// as the raw ephemeral k value in ECDSA (instead of deriving it deterministically). |
| 435 | function signWithNonceUnsafe(uint256 privateKey, bytes32 digest, uint256 nonce) |
| 436 | external |
| 437 | pure |
| 438 | returns (uint8 v, bytes32 r, bytes32 s); |
| 439 | |
| 440 | /// Signs data with a `Wallet`. |
| 441 | function sign(Wallet calldata wallet, bytes32 digest) external returns (uint8 v, bytes32 r, bytes32 s); |
| 442 | |
| 443 | /// Signs `digest` with `privateKey` using the secp256k1 curve. |
| 444 | function sign(uint256 privateKey, bytes32 digest) external pure returns (uint8 v, bytes32 r, bytes32 s); |
| 445 | |
| 446 | /// Signs `digest` with signer provided to script using the secp256k1 curve. |
| 447 | /// If `--sender` is provided, the signer with provided address is used, otherwise, |
| 448 | /// if exactly one signer is provided to the script, that signer is used. |
| 449 | /// Raises error if signer passed through `--sender` does not match any unlocked signers or |
| 450 | /// if `--sender` is not provided and not exactly one signer is passed to the script. |
| 451 | function sign(bytes32 digest) external pure returns (uint8 v, bytes32 r, bytes32 s); |
| 452 | |
| 453 | /// Signs `digest` with signer provided to script using the secp256k1 curve. |
| 454 | /// Raises error if none of the signers passed into the script have provided address. |
| 455 | function sign(address signer, bytes32 digest) external pure returns (uint8 v, bytes32 r, bytes32 s); |
| 456 | |
| 457 | // ======== Environment ======== |
| 458 | |
| 459 | /// Gets the environment variable `name` and parses it as `address`. |
| 460 | /// Reverts if the variable was not found or could not be parsed. |
| 461 | function envAddress(string calldata name) external view returns (address value); |
| 462 | |
| 463 | /// Gets the environment variable `name` and parses it as an array of `address`, delimited by `delim`. |
| 464 | /// Reverts if the variable was not found or could not be parsed. |
| 465 | function envAddress(string calldata name, string calldata delim) external view returns (address[] memory value); |
| 466 | |
| 467 | /// Gets the environment variable `name` and parses it as `bool`. |
| 468 | /// Reverts if the variable was not found or could not be parsed. |
| 469 | function envBool(string calldata name) external view returns (bool value); |
| 470 | |
| 471 | /// Gets the environment variable `name` and parses it as an array of `bool`, delimited by `delim`. |
| 472 | /// Reverts if the variable was not found or could not be parsed. |
| 473 | function envBool(string calldata name, string calldata delim) external view returns (bool[] memory value); |
| 474 | |
| 475 | /// Gets the environment variable `name` and parses it as `bytes32`. |
| 476 | /// Reverts if the variable was not found or could not be parsed. |
| 477 | function envBytes32(string calldata name) external view returns (bytes32 value); |
| 478 | |
| 479 | /// Gets the environment variable `name` and parses it as an array of `bytes32`, delimited by `delim`. |
| 480 | /// Reverts if the variable was not found or could not be parsed. |
| 481 | function envBytes32(string calldata name, string calldata delim) external view returns (bytes32[] memory value); |
| 482 | |
| 483 | /// Gets the environment variable `name` and parses it as `bytes`. |
| 484 | /// Reverts if the variable was not found or could not be parsed. |
| 485 | function envBytes(string calldata name) external view returns (bytes memory value); |
| 486 | |
| 487 | /// Gets the environment variable `name` and parses it as an array of `bytes`, delimited by `delim`. |
| 488 | /// Reverts if the variable was not found or could not be parsed. |
| 489 | function envBytes(string calldata name, string calldata delim) external view returns (bytes[] memory value); |
| 490 | |
| 491 | /// Gets the environment variable `name` and returns true if it exists, else returns false. |
| 492 | function envExists(string calldata name) external view returns (bool result); |
| 493 | |
| 494 | /// Gets the environment variable `name` and parses it as `int256`. |
| 495 | /// Reverts if the variable was not found or could not be parsed. |
| 496 | function envInt(string calldata name) external view returns (int256 value); |
| 497 | |
| 498 | /// Gets the environment variable `name` and parses it as an array of `int256`, delimited by `delim`. |
| 499 | /// Reverts if the variable was not found or could not be parsed. |
| 500 | function envInt(string calldata name, string calldata delim) external view returns (int256[] memory value); |
| 501 | |
| 502 | /// Gets the environment variable `name` and parses it as `bool`. |
| 503 | /// Reverts if the variable could not be parsed. |
| 504 | /// Returns `defaultValue` if the variable was not found. |
| 505 | function envOr(string calldata name, bool defaultValue) external view returns (bool value); |
| 506 | |
| 507 | /// Gets the environment variable `name` and parses it as `uint256`. |
| 508 | /// Reverts if the variable could not be parsed. |
| 509 | /// Returns `defaultValue` if the variable was not found. |
| 510 | function envOr(string calldata name, uint256 defaultValue) external view returns (uint256 value); |
| 511 | |
| 512 | /// Gets the environment variable `name` and parses it as an array of `address`, delimited by `delim`. |
| 513 | /// Reverts if the variable could not be parsed. |
| 514 | /// Returns `defaultValue` if the variable was not found. |
| 515 | function envOr(string calldata name, string calldata delim, address[] calldata defaultValue) |
| 516 | external |
| 517 | view |
| 518 | returns (address[] memory value); |
| 519 | |
| 520 | /// Gets the environment variable `name` and parses it as an array of `bytes32`, delimited by `delim`. |
| 521 | /// Reverts if the variable could not be parsed. |
| 522 | /// Returns `defaultValue` if the variable was not found. |
| 523 | function envOr(string calldata name, string calldata delim, bytes32[] calldata defaultValue) |
| 524 | external |
| 525 | view |
| 526 | returns (bytes32[] memory value); |
| 527 | |
| 528 | /// Gets the environment variable `name` and parses it as an array of `string`, delimited by `delim`. |
| 529 | /// Reverts if the variable could not be parsed. |
| 530 | /// Returns `defaultValue` if the variable was not found. |
| 531 | function envOr(string calldata name, string calldata delim, string[] calldata defaultValue) |
| 532 | external |
| 533 | view |
| 534 | returns (string[] memory value); |
| 535 | |
| 536 | /// Gets the environment variable `name` and parses it as an array of `bytes`, delimited by `delim`. |
| 537 | /// Reverts if the variable could not be parsed. |
| 538 | /// Returns `defaultValue` if the variable was not found. |
| 539 | function envOr(string calldata name, string calldata delim, bytes[] calldata defaultValue) |
| 540 | external |
| 541 | view |
| 542 | returns (bytes[] memory value); |
| 543 | |
| 544 | /// Gets the environment variable `name` and parses it as `int256`. |
| 545 | /// Reverts if the variable could not be parsed. |
| 546 | /// Returns `defaultValue` if the variable was not found. |
| 547 | function envOr(string calldata name, int256 defaultValue) external view returns (int256 value); |
| 548 | |
| 549 | /// Gets the environment variable `name` and parses it as `address`. |
| 550 | /// Reverts if the variable could not be parsed. |
| 551 | /// Returns `defaultValue` if the variable was not found. |
| 552 | function envOr(string calldata name, address defaultValue) external view returns (address value); |
| 553 | |
| 554 | /// Gets the environment variable `name` and parses it as `bytes32`. |
| 555 | /// Reverts if the variable could not be parsed. |
| 556 | /// Returns `defaultValue` if the variable was not found. |
| 557 | function envOr(string calldata name, bytes32 defaultValue) external view returns (bytes32 value); |
| 558 | |
| 559 | /// Gets the environment variable `name` and parses it as `string`. |
| 560 | /// Reverts if the variable could not be parsed. |
| 561 | /// Returns `defaultValue` if the variable was not found. |
| 562 | function envOr(string calldata name, string calldata defaultValue) external view returns (string memory value); |
| 563 | |
| 564 | /// Gets the environment variable `name` and parses it as `bytes`. |
| 565 | /// Reverts if the variable could not be parsed. |
| 566 | /// Returns `defaultValue` if the variable was not found. |
| 567 | function envOr(string calldata name, bytes calldata defaultValue) external view returns (bytes memory value); |
| 568 | |
| 569 | /// Gets the environment variable `name` and parses it as an array of `bool`, delimited by `delim`. |
| 570 | /// Reverts if the variable could not be parsed. |
| 571 | /// Returns `defaultValue` if the variable was not found. |
| 572 | function envOr(string calldata name, string calldata delim, bool[] calldata defaultValue) |
| 573 | external |
| 574 | view |
| 575 | returns (bool[] memory value); |
| 576 | |
| 577 | /// Gets the environment variable `name` and parses it as an array of `uint256`, delimited by `delim`. |
| 578 | /// Reverts if the variable could not be parsed. |
| 579 | /// Returns `defaultValue` if the variable was not found. |
| 580 | function envOr(string calldata name, string calldata delim, uint256[] calldata defaultValue) |
| 581 | external |
| 582 | view |
| 583 | returns (uint256[] memory value); |
| 584 | |
| 585 | /// Gets the environment variable `name` and parses it as an array of `int256`, delimited by `delim`. |
| 586 | /// Reverts if the variable could not be parsed. |
| 587 | /// Returns `defaultValue` if the variable was not found. |
| 588 | function envOr(string calldata name, string calldata delim, int256[] calldata defaultValue) |
| 589 | external |
| 590 | view |
| 591 | returns (int256[] memory value); |
| 592 | |
| 593 | /// Gets the environment variable `name` and parses it as `string`. |
| 594 | /// Reverts if the variable was not found or could not be parsed. |
| 595 | function envString(string calldata name) external view returns (string memory value); |
| 596 | |
| 597 | /// Gets the environment variable `name` and parses it as an array of `string`, delimited by `delim`. |
| 598 | /// Reverts if the variable was not found or could not be parsed. |
| 599 | function envString(string calldata name, string calldata delim) external view returns (string[] memory value); |
| 600 | |
| 601 | /// Gets the environment variable `name` and parses it as `uint256`. |
| 602 | /// Reverts if the variable was not found or could not be parsed. |
| 603 | function envUint(string calldata name) external view returns (uint256 value); |
| 604 | |
| 605 | /// Gets the environment variable `name` and parses it as an array of `uint256`, delimited by `delim`. |
| 606 | /// Reverts if the variable was not found or could not be parsed. |
| 607 | function envUint(string calldata name, string calldata delim) external view returns (uint256[] memory value); |
| 608 | |
| 609 | /// Returns true if `forge` command was executed in given context. |
| 610 | function isContext(ForgeContext context) external view returns (bool result); |
| 611 | |
| 612 | /// Resolves the env variable placeholders of a given input string. |
| 613 | function resolveEnv(string calldata input) external returns (string memory); |
| 614 | |
| 615 | /// Sets environment variables. |
| 616 | function setEnv(string calldata name, string calldata value) external; |
| 617 | |
| 618 | // ======== EVM ======== |
| 619 | |
| 620 | /// Gets all accessed reads and write slot from a `vm.record` session, for a given address. |
| 621 | function accesses(address target) external view returns (bytes32[] memory readSlots, bytes32[] memory writeSlots); |
| 622 | |
| 623 | /// Gets the address for a given private key. |
| 624 | function addr(uint256 privateKey) external pure returns (address keyAddr); |
| 625 | |
| 626 | /// Gets all the logs according to specified filter. |
| 627 | function eth_getLogs(uint256 fromBlock, uint256 toBlock, address target, bytes32[] calldata topics) |
| 628 | external |
| 629 | view |
| 630 | returns (EthGetLogs[] memory logs); |
| 631 | |
| 632 | /// Gets the current `block.blobbasefee`. |
| 633 | /// You should use this instead of `block.blobbasefee` if you use `vm.blobBaseFee`, as `block.blobbasefee` is assumed to be constant across a transaction, |
| 634 | /// and as a result will get optimized out by the compiler. |
| 635 | /// See https://github.com/foundry-rs/foundry/issues/6180 |
| 636 | function getBlobBaseFee() external view returns (uint256 blobBaseFee); |
| 637 | |
| 638 | /// Gets the current `block.number`. |
| 639 | /// You should use this instead of `block.number` if you use `vm.roll`, as `block.number` is assumed to be constant across a transaction, |
| 640 | /// and as a result will get optimized out by the compiler. |
| 641 | /// See https://github.com/foundry-rs/foundry/issues/6180 |
| 642 | function getBlockNumber() external view returns (uint256 height); |
| 643 | |
| 644 | /// Gets the current `block.timestamp`. |
| 645 | /// You should use this instead of `block.timestamp` if you use `vm.warp`, as `block.timestamp` is assumed to be constant across a transaction, |
| 646 | /// and as a result will get optimized out by the compiler. |
| 647 | /// See https://github.com/foundry-rs/foundry/issues/6180 |
| 648 | function getBlockTimestamp() external view returns (uint256 timestamp); |
| 649 | |
| 650 | /// Gets the current `block.chainid` of the currently selected environment. |
| 651 | /// You should use this instead of `block.chainid` if you use `vm.selectFork` or `vm.createSelectFork`, as `block.chainid` could be assumed |
| 652 | /// to be constant across a transaction, and as a result will get optimized out by the compiler. |
| 653 | /// See https://github.com/foundry-rs/foundry/issues/6180 |
| 654 | function getChainId() external view returns (uint256 blockChainId); |
| 655 | |
| 656 | /// Returns the test or script execution evm version. |
| 657 | /// **Note:** The execution evm version is not the same as the compilation one. |
| 658 | function getEvmVersion() external pure returns (string memory evm); |
| 659 | |
| 660 | /// Gets the map key and parent of a mapping at a given slot, for a given address. |
| 661 | function getMappingKeyAndParentOf(address target, bytes32 elementSlot) |
| 662 | external |
| 663 | view |
| 664 | returns (bool found, bytes32 key, bytes32 parent); |
| 665 | |
| 666 | /// Gets the number of elements in the mapping at the given slot, for a given address. |
| 667 | function getMappingLength(address target, bytes32 mappingSlot) external view returns (uint256 length); |
| 668 | |
| 669 | /// Gets the elements at index idx of the mapping at the given slot, for a given address. The |
| 670 | /// index must be less than the length of the mapping (i.e. the number of keys in the mapping). |
| 671 | function getMappingSlotAt(address target, bytes32 mappingSlot, uint256 idx) external view returns (bytes32 value); |
| 672 | |
| 673 | /// Gets the nonce of an account. |
| 674 | function getNonce(address account) external view returns (uint64 nonce); |
| 675 | |
| 676 | /// Get the nonce of a `Wallet`. |
| 677 | function getNonce(Wallet calldata wallet) external view returns (uint64 nonce); |
| 678 | |
| 679 | /// Gets the RLP encoded block header for a given block number. |
| 680 | /// Returns the block header in the same format as `cast block <block_number> --raw`. |
| 681 | function getRawBlockHeader(uint256 blockNumber) external view returns (bytes memory rlpHeader); |
| 682 | |
| 683 | /// Gets all the recorded logs. |
| 684 | function getRecordedLogs() external view returns (Log[] memory logs); |
| 685 | |
| 686 | /// Returns state diffs from current `vm.startStateDiffRecording` session. |
| 687 | function getStateDiff() external view returns (string memory diff); |
| 688 | |
| 689 | /// Returns state diffs from current `vm.startStateDiffRecording` session, in json format. |
| 690 | function getStateDiffJson() external view returns (string memory diff); |
| 691 | |
| 692 | /// Returns an array of `StorageAccess` from current `vm.stateStateDiffRecording` session |
| 693 | function getStorageAccesses() external view returns (StorageAccess[] memory storageAccesses); |
| 694 | |
| 695 | /// Returns an array of storage slots occupied by the specified variable. |
| 696 | function getStorageSlots(address target, string calldata variableName) |
| 697 | external |
| 698 | view |
| 699 | returns (uint256[] memory slots); |
| 700 | |
| 701 | /// Gets the gas used in the last call from the callee perspective. |
| 702 | function lastCallGas() external view returns (Gas memory gas); |
| 703 | |
| 704 | /// Loads a storage slot from an address. |
| 705 | function load(address target, bytes32 slot) external view returns (bytes32 data); |
| 706 | |
| 707 | /// Pauses gas metering (i.e. gas usage is not counted). Noop if already paused. |
| 708 | function pauseGasMetering() external; |
| 709 | |
| 710 | /// Records all storage reads and writes. Use `accesses` to get the recorded data. |
| 711 | /// Subsequent calls to `record` will clear the previous data. |
| 712 | function record() external; |
| 713 | |
| 714 | /// Record all the transaction logs. |
| 715 | function recordLogs() external; |
| 716 | |
| 717 | /// Reset gas metering (i.e. gas usage is set to gas limit). |
| 718 | function resetGasMetering() external; |
| 719 | |
| 720 | /// Resumes gas metering (i.e. gas usage is counted again). Noop if already on. |
| 721 | function resumeGasMetering() external; |
| 722 | |
| 723 | /// Performs an Ethereum JSON-RPC request to the current fork URL. |
| 724 | function rpc(string calldata method, string calldata params) external returns (bytes memory data); |
| 725 | |
| 726 | /// Performs an Ethereum JSON-RPC request to the given endpoint. |
| 727 | function rpc(string calldata urlOrAlias, string calldata method, string calldata params) |
| 728 | external |
| 729 | returns (bytes memory data); |
| 730 | |
| 731 | /// Set the exact test or script execution evm version, e.g. `berlin`, `cancun`. |
| 732 | /// **Note:** The execution evm version is not the same as the compilation one. |
| 733 | function setEvmVersion(string calldata evm) external; |
| 734 | |
| 735 | /// Records the debug trace during the run. |
| 736 | function startDebugTraceRecording() external; |
| 737 | |
| 738 | /// Starts recording all map SSTOREs for later retrieval. |
| 739 | function startMappingRecording() external; |
| 740 | |
| 741 | /// Record all account accesses as part of CREATE, CALL or SELFDESTRUCT opcodes in order, |
| 742 | /// along with the context of the calls |
| 743 | function startStateDiffRecording() external; |
| 744 | |
| 745 | /// Stop debug trace recording and returns the recorded debug trace. |
| 746 | function stopAndReturnDebugTraceRecording() external returns (DebugStep[] memory step); |
| 747 | |
| 748 | /// Returns an ordered array of all account accesses from a `vm.startStateDiffRecording` session. |
| 749 | function stopAndReturnStateDiff() external returns (AccountAccess[] memory accountAccesses); |
| 750 | |
| 751 | /// Stops recording all map SSTOREs for later retrieval and clears the recorded data. |
| 752 | function stopMappingRecording() external; |
| 753 | |
| 754 | /// Stops recording storage reads and writes. |
| 755 | function stopRecord() external; |
| 756 | |
| 757 | // ======== Filesystem ======== |
| 758 | |
| 759 | /// Closes file for reading, resetting the offset and allowing to read it from beginning with readLine. |
| 760 | /// `path` is relative to the project root. |
| 761 | function closeFile(string calldata path) external; |
| 762 | |
| 763 | /// Copies the contents of one file to another. This function will **overwrite** the contents of `to`. |
| 764 | /// On success, the total number of bytes copied is returned and it is equal to the length of the `to` file as reported by `metadata`. |
| 765 | /// Both `from` and `to` are relative to the project root. |
| 766 | function copyFile(string calldata from, string calldata to) external returns (uint64 copied); |
| 767 | |
| 768 | /// Creates a new, empty directory at the provided path. |
| 769 | /// This cheatcode will revert in the following situations, but is not limited to just these cases: |
| 770 | /// - User lacks permissions to modify `path`. |
| 771 | /// - A parent of the given path doesn't exist and `recursive` is false. |
| 772 | /// - `path` already exists and `recursive` is false. |
| 773 | /// `path` is relative to the project root. |
| 774 | function createDir(string calldata path, bool recursive) external; |
| 775 | |
| 776 | /// Deploys a contract from an artifact file. Takes in the relative path to the json file or the path to the |
| 777 | /// artifact in the form of <path>:<contract>:<version> where <contract> and <version> parts are optional. |
| 778 | /// Reverts if the target artifact contains unlinked library placeholders. |
| 779 | function deployCode(string calldata artifactPath) external returns (address deployedAddress); |
| 780 | |
| 781 | /// Deploys a contract from an artifact file. Takes in the relative path to the json file or the path to the |
| 782 | /// artifact in the form of <path>:<contract>:<version> where <contract> and <version> parts are optional. |
| 783 | /// Reverts if the target artifact contains unlinked library placeholders. |
| 784 | /// Additionally accepts abi-encoded constructor arguments. |
| 785 | function deployCode(string calldata artifactPath, bytes calldata constructorArgs) |
| 786 | external |
| 787 | returns (address deployedAddress); |
| 788 | |
| 789 | /// Deploys a contract from an artifact file. Takes in the relative path to the json file or the path to the |
| 790 | /// artifact in the form of <path>:<contract>:<version> where <contract> and <version> parts are optional. |
| 791 | /// Reverts if the target artifact contains unlinked library placeholders. |
| 792 | /// Additionally accepts `msg.value`. |
| 793 | function deployCode(string calldata artifactPath, uint256 value) external returns (address deployedAddress); |
| 794 | |
| 795 | /// Deploys a contract from an artifact file. Takes in the relative path to the json file or the path to the |
| 796 | /// artifact in the form of <path>:<contract>:<version> where <contract> and <version> parts are optional. |
| 797 | /// Reverts if the target artifact contains unlinked library placeholders. |
| 798 | /// Additionally accepts abi-encoded constructor arguments and `msg.value`. |
| 799 | function deployCode(string calldata artifactPath, bytes calldata constructorArgs, uint256 value) |
| 800 | external |
| 801 | returns (address deployedAddress); |
| 802 | |
| 803 | /// Deploys a contract from an artifact file, using the CREATE2 salt. Takes in the relative path to the json file or the path to the |
| 804 | /// artifact in the form of <path>:<contract>:<version> where <contract> and <version> parts are optional. |
| 805 | /// Reverts if the target artifact contains unlinked library placeholders. |
| 806 | function deployCode(string calldata artifactPath, bytes32 salt) external returns (address deployedAddress); |
| 807 | |
| 808 | /// Deploys a contract from an artifact file, using the CREATE2 salt. Takes in the relative path to the json file or the path to the |
| 809 | /// artifact in the form of <path>:<contract>:<version> where <contract> and <version> parts are optional. |
| 810 | /// Reverts if the target artifact contains unlinked library placeholders. |
| 811 | /// Additionally accepts abi-encoded constructor arguments. |
| 812 | function deployCode(string calldata artifactPath, bytes calldata constructorArgs, bytes32 salt) |
| 813 | external |
| 814 | returns (address deployedAddress); |
| 815 | |
| 816 | /// Deploys a contract from an artifact file, using the CREATE2 salt. Takes in the relative path to the json file or the path to the |
| 817 | /// artifact in the form of <path>:<contract>:<version> where <contract> and <version> parts are optional. |
| 818 | /// Reverts if the target artifact contains unlinked library placeholders. |
| 819 | /// Additionally accepts `msg.value`. |
| 820 | function deployCode(string calldata artifactPath, uint256 value, bytes32 salt) |
| 821 | external |
| 822 | returns (address deployedAddress); |
| 823 | |
| 824 | /// Deploys a contract from an artifact file, using the CREATE2 salt. Takes in the relative path to the json file or the path to the |
| 825 | /// artifact in the form of <path>:<contract>:<version> where <contract> and <version> parts are optional. |
| 826 | /// Reverts if the target artifact contains unlinked library placeholders. |
| 827 | /// Additionally accepts abi-encoded constructor arguments and `msg.value`. |
| 828 | function deployCode(string calldata artifactPath, bytes calldata constructorArgs, uint256 value, bytes32 salt) |
| 829 | external |
| 830 | returns (address deployedAddress); |
| 831 | |
| 832 | /// Returns true if the given path points to an existing entity, else returns false. |
| 833 | function exists(string calldata path) external view returns (bool result); |
| 834 | |
| 835 | /// Performs a foreign function call via the terminal. |
| 836 | function ffi(string[] calldata commandInput) external returns (bytes memory result); |
| 837 | |
| 838 | /// Given a path, query the file system to get information about a file, directory, etc. |
| 839 | function fsMetadata(string calldata path) external view returns (FsMetadata memory metadata); |
| 840 | |
| 841 | /// Gets the artifact path from code (aka. creation code). |
| 842 | function getArtifactPathByCode(bytes calldata code) external view returns (string memory path); |
| 843 | |
| 844 | /// Gets the artifact path from deployed code (aka. runtime code). |
| 845 | function getArtifactPathByDeployedCode(bytes calldata deployedCode) external view returns (string memory path); |
| 846 | |
| 847 | /// Returns the most recent broadcast for the given contract on `chainId` matching `txType`. |
| 848 | /// For example: |
| 849 | /// The most recent deployment can be fetched by passing `txType` as `CREATE` or `CREATE2`. |
| 850 | /// The most recent call can be fetched by passing `txType` as `CALL`. |
| 851 | function getBroadcast(string calldata contractName, uint64 chainId, BroadcastTxType txType) |
| 852 | external |
| 853 | view |
| 854 | returns (BroadcastTxSummary memory); |
| 855 | |
| 856 | /// Returns all broadcasts for the given contract on `chainId` with the specified `txType`. |
| 857 | /// Sorted such that the most recent broadcast is the first element, and the oldest is the last. i.e descending order of BroadcastTxSummary.blockNumber. |
| 858 | function getBroadcasts(string calldata contractName, uint64 chainId, BroadcastTxType txType) |
| 859 | external |
| 860 | view |
| 861 | returns (BroadcastTxSummary[] memory); |
| 862 | |
| 863 | /// Returns all broadcasts for the given contract on `chainId`. |
| 864 | /// Sorted such that the most recent broadcast is the first element, and the oldest is the last. i.e descending order of BroadcastTxSummary.blockNumber. |
| 865 | function getBroadcasts(string calldata contractName, uint64 chainId) |
| 866 | external |
| 867 | view |
| 868 | returns (BroadcastTxSummary[] memory); |
| 869 | |
| 870 | /// Gets the creation bytecode from an artifact file. Takes in the relative path to the json file or the path to the |
| 871 | /// artifact in the form of <path>:<contract>:<version> where <contract> and <version> parts are optional. |
| 872 | function getCode(string calldata artifactPath) external view returns (bytes memory creationBytecode); |
| 873 | |
| 874 | /// Gets the deployed bytecode from an artifact file. Takes in the relative path to the json file or the path to the |
| 875 | /// artifact in the form of <path>:<contract>:<version> where <contract> and <version> parts are optional. |
| 876 | function getDeployedCode(string calldata artifactPath) external view returns (bytes memory runtimeBytecode); |
| 877 | |
| 878 | /// Returns the most recent deployment for the current `chainId`. |
| 879 | function getDeployment(string calldata contractName) external view returns (address deployedAddress); |
| 880 | |
| 881 | /// Returns the most recent deployment for the given contract on `chainId` |
| 882 | function getDeployment(string calldata contractName, uint64 chainId) external view returns (address deployedAddress); |
| 883 | |
| 884 | /// Returns all deployments for the given contract on `chainId` |
| 885 | /// Sorted in descending order of deployment time i.e descending order of BroadcastTxSummary.blockNumber. |
| 886 | /// The most recent deployment is the first element, and the oldest is the last. |
| 887 | function getDeployments(string calldata contractName, uint64 chainId) |
| 888 | external |
| 889 | view |
| 890 | returns (address[] memory deployedAddresses); |
| 891 | |
| 892 | /// Returns true if the path exists on disk and is pointing at a directory, else returns false. |
| 893 | function isDir(string calldata path) external view returns (bool result); |
| 894 | |
| 895 | /// Returns true if the path exists on disk and is pointing at a regular file, else returns false. |
| 896 | function isFile(string calldata path) external view returns (bool result); |
| 897 | |
| 898 | /// Get the path of the current project root. |
| 899 | function projectRoot() external view returns (string memory path); |
| 900 | |
| 901 | /// Prompts the user for a string value in the terminal. |
| 902 | function prompt(string calldata promptText) external returns (string memory input); |
| 903 | |
| 904 | /// Prompts the user for an address in the terminal. |
| 905 | function promptAddress(string calldata promptText) external returns (address); |
| 906 | |
| 907 | /// Prompts the user for a hidden string value in the terminal. |
| 908 | function promptSecret(string calldata promptText) external returns (string memory input); |
| 909 | |
| 910 | /// Prompts the user for hidden uint256 in the terminal (usually pk). |
| 911 | function promptSecretUint(string calldata promptText) external returns (uint256); |
| 912 | |
| 913 | /// Prompts the user for uint256 in the terminal. |
| 914 | function promptUint(string calldata promptText) external returns (uint256); |
| 915 | |
| 916 | /// Reads the directory at the given path recursively, up to `maxDepth`. |
| 917 | /// `maxDepth` defaults to 1, meaning only the direct children of the given directory will be returned. |
| 918 | /// Follows symbolic links if `followLinks` is true. |
| 919 | function readDir(string calldata path) external view returns (DirEntry[] memory entries); |
| 920 | |
| 921 | /// See `readDir(string)`. |
| 922 | function readDir(string calldata path, uint64 maxDepth) external view returns (DirEntry[] memory entries); |
| 923 | |
| 924 | /// See `readDir(string)`. |
| 925 | function readDir(string calldata path, uint64 maxDepth, bool followLinks) |
| 926 | external |
| 927 | view |
| 928 | returns (DirEntry[] memory entries); |
| 929 | |
| 930 | /// Reads the entire content of file to string. `path` is relative to the project root. |
| 931 | function readFile(string calldata path) external view returns (string memory data); |
| 932 | |
| 933 | /// Reads the entire content of file as binary. `path` is relative to the project root. |
| 934 | function readFileBinary(string calldata path) external view returns (bytes memory data); |
| 935 | |
| 936 | /// Reads next line of file to string. |
| 937 | function readLine(string calldata path) external view returns (string memory line); |
| 938 | |
| 939 | /// Reads a symbolic link, returning the path that the link points to. |
| 940 | /// This cheatcode will revert in the following situations, but is not limited to just these cases: |
| 941 | /// - `path` is not a symbolic link. |
| 942 | /// - `path` does not exist. |
| 943 | function readLink(string calldata linkPath) external view returns (string memory targetPath); |
| 944 | |
| 945 | /// Removes a directory at the provided path. |
| 946 | /// This cheatcode will revert in the following situations, but is not limited to just these cases: |
| 947 | /// - `path` doesn't exist. |
| 948 | /// - `path` isn't a directory. |
| 949 | /// - User lacks permissions to modify `path`. |
| 950 | /// - The directory is not empty and `recursive` is false. |
| 951 | /// `path` is relative to the project root. |
| 952 | function removeDir(string calldata path, bool recursive) external; |
| 953 | |
| 954 | /// Removes a file from the filesystem. |
| 955 | /// This cheatcode will revert in the following situations, but is not limited to just these cases: |
| 956 | /// - `path` points to a directory. |
| 957 | /// - The file doesn't exist. |
| 958 | /// - The user lacks permissions to remove the file. |
| 959 | /// `path` is relative to the project root. |
| 960 | function removeFile(string calldata path) external; |
| 961 | |
| 962 | /// Performs a foreign function call via terminal and returns the exit code, stdout, and stderr. |
| 963 | function tryFfi(string[] calldata commandInput) external returns (FfiResult memory result); |
| 964 | |
| 965 | /// Returns the time since unix epoch in milliseconds. |
| 966 | function unixTime() external view returns (uint256 milliseconds); |
| 967 | |
| 968 | /// Writes data to file, creating a file if it does not exist, and entirely replacing its contents if it does. |
| 969 | /// `path` is relative to the project root. |
| 970 | function writeFile(string calldata path, string calldata data) external; |
| 971 | |
| 972 | /// Writes binary data to a file, creating a file if it does not exist, and entirely replacing its contents if it does. |
| 973 | /// `path` is relative to the project root. |
| 974 | function writeFileBinary(string calldata path, bytes calldata data) external; |
| 975 | |
| 976 | /// Writes line to file, creating a file if it does not exist. |
| 977 | /// `path` is relative to the project root. |
| 978 | function writeLine(string calldata path, string calldata data) external; |
| 979 | |
| 980 | // ======== JSON ======== |
| 981 | |
| 982 | /// Checks if `key` exists in a JSON object. |
| 983 | function keyExistsJson(string calldata json, string calldata key) external view returns (bool); |
| 984 | |
| 985 | /// Parses a string of JSON data at `key` and coerces it to `address`. |
| 986 | function parseJsonAddress(string calldata json, string calldata key) external pure returns (address); |
| 987 | |
| 988 | /// Parses a string of JSON data at `key` and coerces it to `address[]`. |
| 989 | function parseJsonAddressArray(string calldata json, string calldata key) external pure returns (address[] memory); |
| 990 | |
| 991 | /// Parses a string of JSON data at `key` and coerces it to `bool`. |
| 992 | function parseJsonBool(string calldata json, string calldata key) external pure returns (bool); |
| 993 | |
| 994 | /// Parses a string of JSON data at `key` and coerces it to `bool[]`. |
| 995 | function parseJsonBoolArray(string calldata json, string calldata key) external pure returns (bool[] memory); |
| 996 | |
| 997 | /// Parses a string of JSON data at `key` and coerces it to `bytes`. |
| 998 | function parseJsonBytes(string calldata json, string calldata key) external pure returns (bytes memory); |
| 999 | |
| 1000 | /// Parses a string of JSON data at `key` and coerces it to `bytes32`. |
| 1001 | function parseJsonBytes32(string calldata json, string calldata key) external pure returns (bytes32); |
| 1002 | |
| 1003 | /// Parses a string of JSON data at `key` and coerces it to `bytes32[]`. |
| 1004 | function parseJsonBytes32Array(string calldata json, string calldata key) external pure returns (bytes32[] memory); |
| 1005 | |
| 1006 | /// Parses a string of JSON data at `key` and coerces it to `bytes[]`. |
| 1007 | function parseJsonBytesArray(string calldata json, string calldata key) external pure returns (bytes[] memory); |
| 1008 | |
| 1009 | /// Parses a string of JSON data at `key` and coerces it to `int256`. |
| 1010 | function parseJsonInt(string calldata json, string calldata key) external pure returns (int256); |
| 1011 | |
| 1012 | /// Parses a string of JSON data at `key` and coerces it to `int256[]`. |
| 1013 | function parseJsonIntArray(string calldata json, string calldata key) external pure returns (int256[] memory); |
| 1014 | |
| 1015 | /// Returns an array of all the keys in a JSON object. |
| 1016 | function parseJsonKeys(string calldata json, string calldata key) external pure returns (string[] memory keys); |
| 1017 | |
| 1018 | /// Parses a string of JSON data at `key` and coerces it to `string`. |
| 1019 | function parseJsonString(string calldata json, string calldata key) external pure returns (string memory); |
| 1020 | |
| 1021 | /// Parses a string of JSON data at `key` and coerces it to `string[]`. |
| 1022 | function parseJsonStringArray(string calldata json, string calldata key) external pure returns (string[] memory); |
| 1023 | |
| 1024 | /// Parses a string of JSON data at `key` and coerces it to type array corresponding to `typeDescription`. |
| 1025 | function parseJsonTypeArray(string calldata json, string calldata key, string calldata typeDescription) |
| 1026 | external |
| 1027 | pure |
| 1028 | returns (bytes memory); |
| 1029 | |
| 1030 | /// Parses a string of JSON data and coerces it to type corresponding to `typeDescription`. |
| 1031 | function parseJsonType(string calldata json, string calldata typeDescription) external pure returns (bytes memory); |
| 1032 | |
| 1033 | /// Parses a string of JSON data at `key` and coerces it to type corresponding to `typeDescription`. |
| 1034 | function parseJsonType(string calldata json, string calldata key, string calldata typeDescription) |
| 1035 | external |
| 1036 | pure |
| 1037 | returns (bytes memory); |
| 1038 | |
| 1039 | /// Parses a string of JSON data at `key` and coerces it to `uint256`. |
| 1040 | function parseJsonUint(string calldata json, string calldata key) external pure returns (uint256); |
| 1041 | |
| 1042 | /// Parses a string of JSON data at `key` and coerces it to `uint256[]`. |
| 1043 | function parseJsonUintArray(string calldata json, string calldata key) external pure returns (uint256[] memory); |
| 1044 | |
| 1045 | /// ABI-encodes a JSON object. |
| 1046 | function parseJson(string calldata json) external pure returns (bytes memory abiEncodedData); |
| 1047 | |
| 1048 | /// ABI-encodes a JSON object at `key`. |
| 1049 | function parseJson(string calldata json, string calldata key) external pure returns (bytes memory abiEncodedData); |
| 1050 | |
| 1051 | /// See `serializeJson`. |
| 1052 | function serializeAddress(string calldata objectKey, string calldata valueKey, address value) |
| 1053 | external |
| 1054 | returns (string memory json); |
| 1055 | |
| 1056 | /// See `serializeJson`. |
| 1057 | function serializeAddress(string calldata objectKey, string calldata valueKey, address[] calldata values) |
| 1058 | external |
| 1059 | returns (string memory json); |
| 1060 | |
| 1061 | /// See `serializeJson`. |
| 1062 | function serializeBool(string calldata objectKey, string calldata valueKey, bool value) |
| 1063 | external |
| 1064 | returns (string memory json); |
| 1065 | |
| 1066 | /// See `serializeJson`. |
| 1067 | function serializeBool(string calldata objectKey, string calldata valueKey, bool[] calldata values) |
| 1068 | external |
| 1069 | returns (string memory json); |
| 1070 | |
| 1071 | /// See `serializeJson`. |
| 1072 | function serializeBytes32(string calldata objectKey, string calldata valueKey, bytes32 value) |
| 1073 | external |
| 1074 | returns (string memory json); |
| 1075 | |
| 1076 | /// See `serializeJson`. |
| 1077 | function serializeBytes32(string calldata objectKey, string calldata valueKey, bytes32[] calldata values) |
| 1078 | external |
| 1079 | returns (string memory json); |
| 1080 | |
| 1081 | /// See `serializeJson`. |
| 1082 | function serializeBytes(string calldata objectKey, string calldata valueKey, bytes calldata value) |
| 1083 | external |
| 1084 | returns (string memory json); |
| 1085 | |
| 1086 | /// See `serializeJson`. |
| 1087 | function serializeBytes(string calldata objectKey, string calldata valueKey, bytes[] calldata values) |
| 1088 | external |
| 1089 | returns (string memory json); |
| 1090 | |
| 1091 | /// See `serializeJson`. |
| 1092 | function serializeInt(string calldata objectKey, string calldata valueKey, int256 value) |
| 1093 | external |
| 1094 | returns (string memory json); |
| 1095 | |
| 1096 | /// See `serializeJson`. |
| 1097 | function serializeInt(string calldata objectKey, string calldata valueKey, int256[] calldata values) |
| 1098 | external |
| 1099 | returns (string memory json); |
| 1100 | |
| 1101 | /// Serializes a key and value to a JSON object stored in-memory that can be later written to a file. |
| 1102 | /// Returns the stringified version of the specific JSON file up to that moment. |
| 1103 | function serializeJson(string calldata objectKey, string calldata value) external returns (string memory json); |
| 1104 | |
| 1105 | /// See `serializeJson`. |
| 1106 | function serializeJsonType(string calldata typeDescription, bytes calldata value) |
| 1107 | external |
| 1108 | pure |
| 1109 | returns (string memory json); |
| 1110 | |
| 1111 | /// See `serializeJson`. |
| 1112 | function serializeJsonType( |
| 1113 | string calldata objectKey, |
| 1114 | string calldata valueKey, |
| 1115 | string calldata typeDescription, |
| 1116 | bytes calldata value |
| 1117 | ) external returns (string memory json); |
| 1118 | |
| 1119 | /// See `serializeJson`. |
| 1120 | function serializeString(string calldata objectKey, string calldata valueKey, string calldata value) |
| 1121 | external |
| 1122 | returns (string memory json); |
| 1123 | |
| 1124 | /// See `serializeJson`. |
| 1125 | function serializeString(string calldata objectKey, string calldata valueKey, string[] calldata values) |
| 1126 | external |
| 1127 | returns (string memory json); |
| 1128 | |
| 1129 | /// See `serializeJson`. |
| 1130 | function serializeUintToHex(string calldata objectKey, string calldata valueKey, uint256 value) |
| 1131 | external |
| 1132 | returns (string memory json); |
| 1133 | |
| 1134 | /// See `serializeJson`. |
| 1135 | function serializeUint(string calldata objectKey, string calldata valueKey, uint256 value) |
| 1136 | external |
| 1137 | returns (string memory json); |
| 1138 | |
| 1139 | /// See `serializeJson`. |
| 1140 | function serializeUint(string calldata objectKey, string calldata valueKey, uint256[] calldata values) |
| 1141 | external |
| 1142 | returns (string memory json); |
| 1143 | |
| 1144 | /// Write a serialized JSON object to a file. If the file exists, it will be overwritten. |
| 1145 | function writeJson(string calldata json, string calldata path) external; |
| 1146 | |
| 1147 | /// Write a serialized JSON object to an **existing** JSON file, replacing a value with key = <value_key.> |
| 1148 | /// This is useful to replace a specific value of a JSON file, without having to parse the entire thing. |
| 1149 | /// This cheatcode will create new keys if they didn't previously exist. |
| 1150 | function writeJson(string calldata json, string calldata path, string calldata valueKey) external; |
| 1151 | |
| 1152 | /// Checks if `key` exists in a JSON object |
| 1153 | /// `keyExists` is being deprecated in favor of `keyExistsJson`. It will be removed in future versions. |
| 1154 | function keyExists(string calldata json, string calldata key) external view returns (bool); |
| 1155 | |
| 1156 | // ======== Scripting ======== |
| 1157 | |
| 1158 | /// Attach an EIP-4844 blob to the next call |
| 1159 | function attachBlob(bytes calldata blob) external; |
| 1160 | |
| 1161 | /// Designate the next call as an EIP-7702 transaction |
| 1162 | function attachDelegation(SignedDelegation calldata signedDelegation) external; |
| 1163 | |
| 1164 | /// Designate the next call as an EIP-7702 transaction, with optional cross-chain validity. |
| 1165 | function attachDelegation(SignedDelegation calldata signedDelegation, bool crossChain) external; |
| 1166 | |
| 1167 | /// Takes a signed transaction and broadcasts it to the network. |
| 1168 | function broadcastRawTransaction(bytes calldata data) external; |
| 1169 | |
| 1170 | /// Has the next call (at this call depth only) create transactions that can later be signed and sent onchain. |
| 1171 | /// Broadcasting address is determined by checking the following in order: |
| 1172 | /// 1. If `--sender` argument was provided, that address is used. |
| 1173 | /// 2. If exactly one signer (e.g. private key, hw wallet, keystore) is set when `forge broadcast` is invoked, that signer is used. |
| 1174 | /// 3. Otherwise, default foundry sender (1804c8AB1F12E6bbf3894d4083f33e07309d1f38) is used. |
| 1175 | function broadcast() external; |
| 1176 | |
| 1177 | /// Has the next call (at this call depth only) create a transaction with the address provided |
| 1178 | /// as the sender that can later be signed and sent onchain. |
| 1179 | function broadcast(address signer) external; |
| 1180 | |
| 1181 | /// Has the next call (at this call depth only) create a transaction with the private key |
| 1182 | /// provided as the sender that can later be signed and sent onchain. |
| 1183 | function broadcast(uint256 privateKey) external; |
| 1184 | |
| 1185 | /// Returns addresses of available unlocked wallets in the script environment. |
| 1186 | function getWallets() external view returns (address[] memory wallets); |
| 1187 | |
| 1188 | /// Sign an EIP-7702 authorization and designate the next call as an EIP-7702 transaction |
| 1189 | function signAndAttachDelegation(address implementation, uint256 privateKey) |
| 1190 | external |
| 1191 | returns (SignedDelegation memory signedDelegation); |
| 1192 | |
| 1193 | /// Sign an EIP-7702 authorization and designate the next call as an EIP-7702 transaction for specific nonce |
| 1194 | function signAndAttachDelegation(address implementation, uint256 privateKey, uint64 nonce) |
| 1195 | external |
| 1196 | returns (SignedDelegation memory signedDelegation); |
| 1197 | |
| 1198 | /// Sign an EIP-7702 authorization and designate the next call as an EIP-7702 transaction, with optional cross-chain validity. |
| 1199 | function signAndAttachDelegation(address implementation, uint256 privateKey, bool crossChain) |
| 1200 | external |
| 1201 | returns (SignedDelegation memory signedDelegation); |
| 1202 | |
| 1203 | /// Sign an EIP-7702 authorization for delegation |
| 1204 | function signDelegation(address implementation, uint256 privateKey) |
| 1205 | external |
| 1206 | returns (SignedDelegation memory signedDelegation); |
| 1207 | |
| 1208 | /// Sign an EIP-7702 authorization for delegation for specific nonce |
| 1209 | function signDelegation(address implementation, uint256 privateKey, uint64 nonce) |
| 1210 | external |
| 1211 | returns (SignedDelegation memory signedDelegation); |
| 1212 | |
| 1213 | /// Sign an EIP-7702 authorization for delegation, with optional cross-chain validity. |
| 1214 | function signDelegation(address implementation, uint256 privateKey, bool crossChain) |
| 1215 | external |
| 1216 | returns (SignedDelegation memory signedDelegation); |
| 1217 | |
| 1218 | /// Has all subsequent calls (at this call depth only) create transactions that can later be signed and sent onchain. |
| 1219 | /// Broadcasting address is determined by checking the following in order: |
| 1220 | /// 1. If `--sender` argument was provided, that address is used. |
| 1221 | /// 2. If exactly one signer (e.g. private key, hw wallet, keystore) is set when `forge broadcast` is invoked, that signer is used. |
| 1222 | /// 3. Otherwise, default foundry sender (1804c8AB1F12E6bbf3894d4083f33e07309d1f38) is used. |
| 1223 | function startBroadcast() external; |
| 1224 | |
| 1225 | /// Has all subsequent calls (at this call depth only) create transactions with the address |
| 1226 | /// provided that can later be signed and sent onchain. |
| 1227 | function startBroadcast(address signer) external; |
| 1228 | |
| 1229 | /// Has all subsequent calls (at this call depth only) create transactions with the private key |
| 1230 | /// provided that can later be signed and sent onchain. |
| 1231 | function startBroadcast(uint256 privateKey) external; |
| 1232 | |
| 1233 | /// Stops collecting onchain transactions. |
| 1234 | function stopBroadcast() external; |
| 1235 | |
| 1236 | // ======== String ======== |
| 1237 | |
| 1238 | /// Returns true if `search` is found in `subject`, false otherwise. |
| 1239 | function contains(string calldata subject, string calldata search) external pure returns (bool result); |
| 1240 | |
| 1241 | /// Returns the index of the first occurrence of a `key` in an `input` string. |
| 1242 | /// Returns `NOT_FOUND` (i.e. `type(uint256).max`) if the `key` is not found. |
| 1243 | /// Returns 0 in case of an empty `key`. |
| 1244 | function indexOf(string calldata input, string calldata key) external pure returns (uint256); |
| 1245 | |
| 1246 | /// Parses the given `string` into an `address`. |
| 1247 | function parseAddress(string calldata stringifiedValue) external pure returns (address parsedValue); |
| 1248 | |
| 1249 | /// Parses the given `string` into a `bool`. |
| 1250 | function parseBool(string calldata stringifiedValue) external pure returns (bool parsedValue); |
| 1251 | |
| 1252 | /// Parses the given `string` into `bytes`. |
| 1253 | function parseBytes(string calldata stringifiedValue) external pure returns (bytes memory parsedValue); |
| 1254 | |
| 1255 | /// Parses the given `string` into a `bytes32`. |
| 1256 | function parseBytes32(string calldata stringifiedValue) external pure returns (bytes32 parsedValue); |
| 1257 | |
| 1258 | /// Parses the given `string` into a `int256`. |
| 1259 | function parseInt(string calldata stringifiedValue) external pure returns (int256 parsedValue); |
| 1260 | |
| 1261 | /// Parses the given `string` into a `uint256`. |
| 1262 | function parseUint(string calldata stringifiedValue) external pure returns (uint256 parsedValue); |
| 1263 | |
| 1264 | /// Replaces occurrences of `from` in the given `string` with `to`. |
| 1265 | function replace(string calldata input, string calldata from, string calldata to) |
| 1266 | external |
| 1267 | pure |
| 1268 | returns (string memory output); |
| 1269 | |
| 1270 | /// Splits the given `string` into an array of strings divided by the `delimiter`. |
| 1271 | function split(string calldata input, string calldata delimiter) external pure returns (string[] memory outputs); |
| 1272 | |
| 1273 | /// Converts the given `string` value to Lowercase. |
| 1274 | function toLowercase(string calldata input) external pure returns (string memory output); |
| 1275 | |
| 1276 | /// Converts the given value to a `string`. |
| 1277 | function toString(address value) external pure returns (string memory stringifiedValue); |
| 1278 | |
| 1279 | /// Converts the given value to a `string`. |
| 1280 | function toString(bytes calldata value) external pure returns (string memory stringifiedValue); |
| 1281 | |
| 1282 | /// Converts the given value to a `string`. |
| 1283 | function toString(bytes32 value) external pure returns (string memory stringifiedValue); |
| 1284 | |
| 1285 | /// Converts the given value to a `string`. |
| 1286 | function toString(bool value) external pure returns (string memory stringifiedValue); |
| 1287 | |
| 1288 | /// Converts the given value to a `string`. |
| 1289 | function toString(uint256 value) external pure returns (string memory stringifiedValue); |
| 1290 | |
| 1291 | /// Converts the given value to a `string`. |
| 1292 | function toString(int256 value) external pure returns (string memory stringifiedValue); |
| 1293 | |
| 1294 | /// Converts the given `string` value to Uppercase. |
| 1295 | function toUppercase(string calldata input) external pure returns (string memory output); |
| 1296 | |
| 1297 | /// Trims leading and trailing whitespace from the given `string` value. |
| 1298 | function trim(string calldata input) external pure returns (string memory output); |
| 1299 | |
| 1300 | // ======== Testing ======== |
| 1301 | |
| 1302 | /// Compares two `uint256` values. Expects difference to be less than or equal to `maxDelta`. |
| 1303 | /// Formats values with decimals in failure message. |
| 1304 | function assertApproxEqAbsDecimal(uint256 left, uint256 right, uint256 maxDelta, uint256 decimals) external pure; |
| 1305 | |
| 1306 | /// Compares two `uint256` values. Expects difference to be less than or equal to `maxDelta`. |
| 1307 | /// Formats values with decimals in failure message. Includes error message into revert string on failure. |
| 1308 | function assertApproxEqAbsDecimal( |
| 1309 | uint256 left, |
| 1310 | uint256 right, |
| 1311 | uint256 maxDelta, |
| 1312 | uint256 decimals, |
| 1313 | string calldata error |
| 1314 | ) external pure; |
| 1315 | |
| 1316 | /// Compares two `int256` values. Expects difference to be less than or equal to `maxDelta`. |
| 1317 | /// Formats values with decimals in failure message. |
| 1318 | function assertApproxEqAbsDecimal(int256 left, int256 right, uint256 maxDelta, uint256 decimals) external pure; |
| 1319 | |
| 1320 | /// Compares two `int256` values. Expects difference to be less than or equal to `maxDelta`. |
| 1321 | /// Formats values with decimals in failure message. Includes error message into revert string on failure. |
| 1322 | function assertApproxEqAbsDecimal( |
| 1323 | int256 left, |
| 1324 | int256 right, |
| 1325 | uint256 maxDelta, |
| 1326 | uint256 decimals, |
| 1327 | string calldata error |
| 1328 | ) external pure; |
| 1329 | |
| 1330 | /// Compares two `uint256` values. Expects difference to be less than or equal to `maxDelta`. |
| 1331 | function assertApproxEqAbs(uint256 left, uint256 right, uint256 maxDelta) external pure; |
| 1332 | |
| 1333 | /// Compares two `uint256` values. Expects difference to be less than or equal to `maxDelta`. |
| 1334 | /// Includes error message into revert string on failure. |
| 1335 | function assertApproxEqAbs(uint256 left, uint256 right, uint256 maxDelta, string calldata error) external pure; |
| 1336 | |
| 1337 | /// Compares two `int256` values. Expects difference to be less than or equal to `maxDelta`. |
| 1338 | function assertApproxEqAbs(int256 left, int256 right, uint256 maxDelta) external pure; |
| 1339 | |
| 1340 | /// Compares two `int256` values. Expects difference to be less than or equal to `maxDelta`. |
| 1341 | /// Includes error message into revert string on failure. |
| 1342 | function assertApproxEqAbs(int256 left, int256 right, uint256 maxDelta, string calldata error) external pure; |
| 1343 | |
| 1344 | /// Compares two `uint256` values. Expects relative difference in percents to be less than or equal to `maxPercentDelta`. |
| 1345 | /// `maxPercentDelta` is an 18 decimal fixed point number, where 1e18 == 100% |
| 1346 | /// Formats values with decimals in failure message. |
| 1347 | function assertApproxEqRelDecimal(uint256 left, uint256 right, uint256 maxPercentDelta, uint256 decimals) |
| 1348 | external |
| 1349 | pure; |
| 1350 | |
| 1351 | /// Compares two `uint256` values. Expects relative difference in percents to be less than or equal to `maxPercentDelta`. |
| 1352 | /// `maxPercentDelta` is an 18 decimal fixed point number, where 1e18 == 100% |
| 1353 | /// Formats values with decimals in failure message. Includes error message into revert string on failure. |
| 1354 | function assertApproxEqRelDecimal( |
| 1355 | uint256 left, |
| 1356 | uint256 right, |
| 1357 | uint256 maxPercentDelta, |
| 1358 | uint256 decimals, |
| 1359 | string calldata error |
| 1360 | ) external pure; |
| 1361 | |
| 1362 | /// Compares two `int256` values. Expects relative difference in percents to be less than or equal to `maxPercentDelta`. |
| 1363 | /// `maxPercentDelta` is an 18 decimal fixed point number, where 1e18 == 100% |
| 1364 | /// Formats values with decimals in failure message. |
| 1365 | function assertApproxEqRelDecimal(int256 left, int256 right, uint256 maxPercentDelta, uint256 decimals) |
| 1366 | external |
| 1367 | pure; |
| 1368 | |
| 1369 | /// Compares two `int256` values. Expects relative difference in percents to be less than or equal to `maxPercentDelta`. |
| 1370 | /// `maxPercentDelta` is an 18 decimal fixed point number, where 1e18 == 100% |
| 1371 | /// Formats values with decimals in failure message. Includes error message into revert string on failure. |
| 1372 | function assertApproxEqRelDecimal( |
| 1373 | int256 left, |
| 1374 | int256 right, |
| 1375 | uint256 maxPercentDelta, |
| 1376 | uint256 decimals, |
| 1377 | string calldata error |
| 1378 | ) external pure; |
| 1379 | |
| 1380 | /// Compares two `uint256` values. Expects relative difference in percents to be less than or equal to `maxPercentDelta`. |
| 1381 | /// `maxPercentDelta` is an 18 decimal fixed point number, where 1e18 == 100% |
| 1382 | function assertApproxEqRel(uint256 left, uint256 right, uint256 maxPercentDelta) external pure; |
| 1383 | |
| 1384 | /// Compares two `uint256` values. Expects relative difference in percents to be less than or equal to `maxPercentDelta`. |
| 1385 | /// `maxPercentDelta` is an 18 decimal fixed point number, where 1e18 == 100% |
| 1386 | /// Includes error message into revert string on failure. |
| 1387 | function assertApproxEqRel(uint256 left, uint256 right, uint256 maxPercentDelta, string calldata error) |
| 1388 | external |
| 1389 | pure; |
| 1390 | |
| 1391 | /// Compares two `int256` values. Expects relative difference in percents to be less than or equal to `maxPercentDelta`. |
| 1392 | /// `maxPercentDelta` is an 18 decimal fixed point number, where 1e18 == 100% |
| 1393 | function assertApproxEqRel(int256 left, int256 right, uint256 maxPercentDelta) external pure; |
| 1394 | |
| 1395 | /// Compares two `int256` values. Expects relative difference in percents to be less than or equal to `maxPercentDelta`. |
| 1396 | /// `maxPercentDelta` is an 18 decimal fixed point number, where 1e18 == 100% |
| 1397 | /// Includes error message into revert string on failure. |
| 1398 | function assertApproxEqRel(int256 left, int256 right, uint256 maxPercentDelta, string calldata error) external pure; |
| 1399 | |
| 1400 | /// Asserts that two `uint256` values are equal, formatting them with decimals in failure message. |
| 1401 | function assertEqDecimal(uint256 left, uint256 right, uint256 decimals) external pure; |
| 1402 | |
| 1403 | /// Asserts that two `uint256` values are equal, formatting them with decimals in failure message. |
| 1404 | /// Includes error message into revert string on failure. |
| 1405 | function assertEqDecimal(uint256 left, uint256 right, uint256 decimals, string calldata error) external pure; |
| 1406 | |
| 1407 | /// Asserts that two `int256` values are equal, formatting them with decimals in failure message. |
| 1408 | function assertEqDecimal(int256 left, int256 right, uint256 decimals) external pure; |
| 1409 | |
| 1410 | /// Asserts that two `int256` values are equal, formatting them with decimals in failure message. |
| 1411 | /// Includes error message into revert string on failure. |
| 1412 | function assertEqDecimal(int256 left, int256 right, uint256 decimals, string calldata error) external pure; |
| 1413 | |
| 1414 | /// Asserts that two `bool` values are equal. |
| 1415 | function assertEq(bool left, bool right) external pure; |
| 1416 | |
| 1417 | /// Asserts that two `bool` values are equal and includes error message into revert string on failure. |
| 1418 | function assertEq(bool left, bool right, string calldata error) external pure; |
| 1419 | |
| 1420 | /// Asserts that two `string` values are equal. |
| 1421 | function assertEq(string calldata left, string calldata right) external pure; |
| 1422 | |
| 1423 | /// Asserts that two `string` values are equal and includes error message into revert string on failure. |
| 1424 | function assertEq(string calldata left, string calldata right, string calldata error) external pure; |
| 1425 | |
| 1426 | /// Asserts that two `bytes` values are equal. |
| 1427 | function assertEq(bytes calldata left, bytes calldata right) external pure; |
| 1428 | |
| 1429 | /// Asserts that two `bytes` values are equal and includes error message into revert string on failure. |
| 1430 | function assertEq(bytes calldata left, bytes calldata right, string calldata error) external pure; |
| 1431 | |
| 1432 | /// Asserts that two arrays of `bool` values are equal. |
| 1433 | function assertEq(bool[] calldata left, bool[] calldata right) external pure; |
| 1434 | |
| 1435 | /// Asserts that two arrays of `bool` values are equal and includes error message into revert string on failure. |
| 1436 | function assertEq(bool[] calldata left, bool[] calldata right, string calldata error) external pure; |
| 1437 | |
| 1438 | /// Asserts that two arrays of `uint256 values are equal. |
| 1439 | function assertEq(uint256[] calldata left, uint256[] calldata right) external pure; |
| 1440 | |
| 1441 | /// Asserts that two arrays of `uint256` values are equal and includes error message into revert string on failure. |
| 1442 | function assertEq(uint256[] calldata left, uint256[] calldata right, string calldata error) external pure; |
| 1443 | |
| 1444 | /// Asserts that two arrays of `int256` values are equal. |
| 1445 | function assertEq(int256[] calldata left, int256[] calldata right) external pure; |
| 1446 | |
| 1447 | /// Asserts that two arrays of `int256` values are equal and includes error message into revert string on failure. |
| 1448 | function assertEq(int256[] calldata left, int256[] calldata right, string calldata error) external pure; |
| 1449 | |
| 1450 | /// Asserts that two `uint256` values are equal. |
| 1451 | function assertEq(uint256 left, uint256 right) external pure; |
| 1452 | |
| 1453 | /// Asserts that two arrays of `address` values are equal. |
| 1454 | function assertEq(address[] calldata left, address[] calldata right) external pure; |
| 1455 | |
| 1456 | /// Asserts that two arrays of `address` values are equal and includes error message into revert string on failure. |
| 1457 | function assertEq(address[] calldata left, address[] calldata right, string calldata error) external pure; |
| 1458 | |
| 1459 | /// Asserts that two arrays of `bytes32` values are equal. |
| 1460 | function assertEq(bytes32[] calldata left, bytes32[] calldata right) external pure; |
| 1461 | |
| 1462 | /// Asserts that two arrays of `bytes32` values are equal and includes error message into revert string on failure. |
| 1463 | function assertEq(bytes32[] calldata left, bytes32[] calldata right, string calldata error) external pure; |
| 1464 | |
| 1465 | /// Asserts that two arrays of `string` values are equal. |
| 1466 | function assertEq(string[] calldata left, string[] calldata right) external pure; |
| 1467 | |
| 1468 | /// Asserts that two arrays of `string` values are equal and includes error message into revert string on failure. |
| 1469 | function assertEq(string[] calldata left, string[] calldata right, string calldata error) external pure; |
| 1470 | |
| 1471 | /// Asserts that two arrays of `bytes` values are equal. |
| 1472 | function assertEq(bytes[] calldata left, bytes[] calldata right) external pure; |
| 1473 | |
| 1474 | /// Asserts that two arrays of `bytes` values are equal and includes error message into revert string on failure. |
| 1475 | function assertEq(bytes[] calldata left, bytes[] calldata right, string calldata error) external pure; |
| 1476 | |
| 1477 | /// Asserts that two `uint256` values are equal and includes error message into revert string on failure. |
| 1478 | function assertEq(uint256 left, uint256 right, string calldata error) external pure; |
| 1479 | |
| 1480 | /// Asserts that two `int256` values are equal. |
| 1481 | function assertEq(int256 left, int256 right) external pure; |
| 1482 | |
| 1483 | /// Asserts that two `int256` values are equal and includes error message into revert string on failure. |
| 1484 | function assertEq(int256 left, int256 right, string calldata error) external pure; |
| 1485 | |
| 1486 | /// Asserts that two `address` values are equal. |
| 1487 | function assertEq(address left, address right) external pure; |
| 1488 | |
| 1489 | /// Asserts that two `address` values are equal and includes error message into revert string on failure. |
| 1490 | function assertEq(address left, address right, string calldata error) external pure; |
| 1491 | |
| 1492 | /// Asserts that two `bytes32` values are equal. |
| 1493 | function assertEq(bytes32 left, bytes32 right) external pure; |
| 1494 | |
| 1495 | /// Asserts that two `bytes32` values are equal and includes error message into revert string on failure. |
| 1496 | function assertEq(bytes32 left, bytes32 right, string calldata error) external pure; |
| 1497 | |
| 1498 | /// Asserts that the given condition is false. |
| 1499 | function assertFalse(bool condition) external pure; |
| 1500 | |
| 1501 | /// Asserts that the given condition is false and includes error message into revert string on failure. |
| 1502 | function assertFalse(bool condition, string calldata error) external pure; |
| 1503 | |
| 1504 | /// Compares two `uint256` values. Expects first value to be greater than or equal to second. |
| 1505 | /// Formats values with decimals in failure message. |
| 1506 | function assertGeDecimal(uint256 left, uint256 right, uint256 decimals) external pure; |
| 1507 | |
| 1508 | /// Compares two `uint256` values. Expects first value to be greater than or equal to second. |
| 1509 | /// Formats values with decimals in failure message. Includes error message into revert string on failure. |
| 1510 | function assertGeDecimal(uint256 left, uint256 right, uint256 decimals, string calldata error) external pure; |
| 1511 | |
| 1512 | /// Compares two `int256` values. Expects first value to be greater than or equal to second. |
| 1513 | /// Formats values with decimals in failure message. |
| 1514 | function assertGeDecimal(int256 left, int256 right, uint256 decimals) external pure; |
| 1515 | |
| 1516 | /// Compares two `int256` values. Expects first value to be greater than or equal to second. |
| 1517 | /// Formats values with decimals in failure message. Includes error message into revert string on failure. |
| 1518 | function assertGeDecimal(int256 left, int256 right, uint256 decimals, string calldata error) external pure; |
| 1519 | |
| 1520 | /// Compares two `uint256` values. Expects first value to be greater than or equal to second. |
| 1521 | function assertGe(uint256 left, uint256 right) external pure; |
| 1522 | |
| 1523 | /// Compares two `uint256` values. Expects first value to be greater than or equal to second. |
| 1524 | /// Includes error message into revert string on failure. |
| 1525 | function assertGe(uint256 left, uint256 right, string calldata error) external pure; |
| 1526 | |
| 1527 | /// Compares two `int256` values. Expects first value to be greater than or equal to second. |
| 1528 | function assertGe(int256 left, int256 right) external pure; |
| 1529 | |
| 1530 | /// Compares two `int256` values. Expects first value to be greater than or equal to second. |
| 1531 | /// Includes error message into revert string on failure. |
| 1532 | function assertGe(int256 left, int256 right, string calldata error) external pure; |
| 1533 | |
| 1534 | /// Compares two `uint256` values. Expects first value to be greater than second. |
| 1535 | /// Formats values with decimals in failure message. |
| 1536 | function assertGtDecimal(uint256 left, uint256 right, uint256 decimals) external pure; |
| 1537 | |
| 1538 | /// Compares two `uint256` values. Expects first value to be greater than second. |
| 1539 | /// Formats values with decimals in failure message. Includes error message into revert string on failure. |
| 1540 | function assertGtDecimal(uint256 left, uint256 right, uint256 decimals, string calldata error) external pure; |
| 1541 | |
| 1542 | /// Compares two `int256` values. Expects first value to be greater than second. |
| 1543 | /// Formats values with decimals in failure message. |
| 1544 | function assertGtDecimal(int256 left, int256 right, uint256 decimals) external pure; |
| 1545 | |
| 1546 | /// Compares two `int256` values. Expects first value to be greater than second. |
| 1547 | /// Formats values with decimals in failure message. Includes error message into revert string on failure. |
| 1548 | function assertGtDecimal(int256 left, int256 right, uint256 decimals, string calldata error) external pure; |
| 1549 | |
| 1550 | /// Compares two `uint256` values. Expects first value to be greater than second. |
| 1551 | function assertGt(uint256 left, uint256 right) external pure; |
| 1552 | |
| 1553 | /// Compares two `uint256` values. Expects first value to be greater than second. |
| 1554 | /// Includes error message into revert string on failure. |
| 1555 | function assertGt(uint256 left, uint256 right, string calldata error) external pure; |
| 1556 | |
| 1557 | /// Compares two `int256` values. Expects first value to be greater than second. |
| 1558 | function assertGt(int256 left, int256 right) external pure; |
| 1559 | |
| 1560 | /// Compares two `int256` values. Expects first value to be greater than second. |
| 1561 | /// Includes error message into revert string on failure. |
| 1562 | function assertGt(int256 left, int256 right, string calldata error) external pure; |
| 1563 | |
| 1564 | /// Compares two `uint256` values. Expects first value to be less than or equal to second. |
| 1565 | /// Formats values with decimals in failure message. |
| 1566 | function assertLeDecimal(uint256 left, uint256 right, uint256 decimals) external pure; |
| 1567 | |
| 1568 | /// Compares two `uint256` values. Expects first value to be less than or equal to second. |
| 1569 | /// Formats values with decimals in failure message. Includes error message into revert string on failure. |
| 1570 | function assertLeDecimal(uint256 left, uint256 right, uint256 decimals, string calldata error) external pure; |
| 1571 | |
| 1572 | /// Compares two `int256` values. Expects first value to be less than or equal to second. |
| 1573 | /// Formats values with decimals in failure message. |
| 1574 | function assertLeDecimal(int256 left, int256 right, uint256 decimals) external pure; |
| 1575 | |
| 1576 | /// Compares two `int256` values. Expects first value to be less than or equal to second. |
| 1577 | /// Formats values with decimals in failure message. Includes error message into revert string on failure. |
| 1578 | function assertLeDecimal(int256 left, int256 right, uint256 decimals, string calldata error) external pure; |
| 1579 | |
| 1580 | /// Compares two `uint256` values. Expects first value to be less than or equal to second. |
| 1581 | function assertLe(uint256 left, uint256 right) external pure; |
| 1582 | |
| 1583 | /// Compares two `uint256` values. Expects first value to be less than or equal to second. |
| 1584 | /// Includes error message into revert string on failure. |
| 1585 | function assertLe(uint256 left, uint256 right, string calldata error) external pure; |
| 1586 | |
| 1587 | /// Compares two `int256` values. Expects first value to be less than or equal to second. |
| 1588 | function assertLe(int256 left, int256 right) external pure; |
| 1589 | |
| 1590 | /// Compares two `int256` values. Expects first value to be less than or equal to second. |
| 1591 | /// Includes error message into revert string on failure. |
| 1592 | function assertLe(int256 left, int256 right, string calldata error) external pure; |
| 1593 | |
| 1594 | /// Compares two `uint256` values. Expects first value to be less than second. |
| 1595 | /// Formats values with decimals in failure message. |
| 1596 | function assertLtDecimal(uint256 left, uint256 right, uint256 decimals) external pure; |
| 1597 | |
| 1598 | /// Compares two `uint256` values. Expects first value to be less than second. |
| 1599 | /// Formats values with decimals in failure message. Includes error message into revert string on failure. |
| 1600 | function assertLtDecimal(uint256 left, uint256 right, uint256 decimals, string calldata error) external pure; |
| 1601 | |
| 1602 | /// Compares two `int256` values. Expects first value to be less than second. |
| 1603 | /// Formats values with decimals in failure message. |
| 1604 | function assertLtDecimal(int256 left, int256 right, uint256 decimals) external pure; |
| 1605 | |
| 1606 | /// Compares two `int256` values. Expects first value to be less than second. |
| 1607 | /// Formats values with decimals in failure message. Includes error message into revert string on failure. |
| 1608 | function assertLtDecimal(int256 left, int256 right, uint256 decimals, string calldata error) external pure; |
| 1609 | |
| 1610 | /// Compares two `uint256` values. Expects first value to be less than second. |
| 1611 | function assertLt(uint256 left, uint256 right) external pure; |
| 1612 | |
| 1613 | /// Compares two `uint256` values. Expects first value to be less than second. |
| 1614 | /// Includes error message into revert string on failure. |
| 1615 | function assertLt(uint256 left, uint256 right, string calldata error) external pure; |
| 1616 | |
| 1617 | /// Compares two `int256` values. Expects first value to be less than second. |
| 1618 | function assertLt(int256 left, int256 right) external pure; |
| 1619 | |
| 1620 | /// Compares two `int256` values. Expects first value to be less than second. |
| 1621 | /// Includes error message into revert string on failure. |
| 1622 | function assertLt(int256 left, int256 right, string calldata error) external pure; |
| 1623 | |
| 1624 | /// Asserts that two `uint256` values are not equal, formatting them with decimals in failure message. |
| 1625 | function assertNotEqDecimal(uint256 left, uint256 right, uint256 decimals) external pure; |
| 1626 | |
| 1627 | /// Asserts that two `uint256` values are not equal, formatting them with decimals in failure message. |
| 1628 | /// Includes error message into revert string on failure. |
| 1629 | function assertNotEqDecimal(uint256 left, uint256 right, uint256 decimals, string calldata error) external pure; |
| 1630 | |
| 1631 | /// Asserts that two `int256` values are not equal, formatting them with decimals in failure message. |
| 1632 | function assertNotEqDecimal(int256 left, int256 right, uint256 decimals) external pure; |
| 1633 | |
| 1634 | /// Asserts that two `int256` values are not equal, formatting them with decimals in failure message. |
| 1635 | /// Includes error message into revert string on failure. |
| 1636 | function assertNotEqDecimal(int256 left, int256 right, uint256 decimals, string calldata error) external pure; |
| 1637 | |
| 1638 | /// Asserts that two `bool` values are not equal. |
| 1639 | function assertNotEq(bool left, bool right) external pure; |
| 1640 | |
| 1641 | /// Asserts that two `bool` values are not equal and includes error message into revert string on failure. |
| 1642 | function assertNotEq(bool left, bool right, string calldata error) external pure; |
| 1643 | |
| 1644 | /// Asserts that two `string` values are not equal. |
| 1645 | function assertNotEq(string calldata left, string calldata right) external pure; |
| 1646 | |
| 1647 | /// Asserts that two `string` values are not equal and includes error message into revert string on failure. |
| 1648 | function assertNotEq(string calldata left, string calldata right, string calldata error) external pure; |
| 1649 | |
| 1650 | /// Asserts that two `bytes` values are not equal. |
| 1651 | function assertNotEq(bytes calldata left, bytes calldata right) external pure; |
| 1652 | |
| 1653 | /// Asserts that two `bytes` values are not equal and includes error message into revert string on failure. |
| 1654 | function assertNotEq(bytes calldata left, bytes calldata right, string calldata error) external pure; |
| 1655 | |
| 1656 | /// Asserts that two arrays of `bool` values are not equal. |
| 1657 | function assertNotEq(bool[] calldata left, bool[] calldata right) external pure; |
| 1658 | |
| 1659 | /// Asserts that two arrays of `bool` values are not equal and includes error message into revert string on failure. |
| 1660 | function assertNotEq(bool[] calldata left, bool[] calldata right, string calldata error) external pure; |
| 1661 | |
| 1662 | /// Asserts that two arrays of `uint256` values are not equal. |
| 1663 | function assertNotEq(uint256[] calldata left, uint256[] calldata right) external pure; |
| 1664 | |
| 1665 | /// Asserts that two arrays of `uint256` values are not equal and includes error message into revert string on failure. |
| 1666 | function assertNotEq(uint256[] calldata left, uint256[] calldata right, string calldata error) external pure; |
| 1667 | |
| 1668 | /// Asserts that two arrays of `int256` values are not equal. |
| 1669 | function assertNotEq(int256[] calldata left, int256[] calldata right) external pure; |
| 1670 | |
| 1671 | /// Asserts that two arrays of `int256` values are not equal and includes error message into revert string on failure. |
| 1672 | function assertNotEq(int256[] calldata left, int256[] calldata right, string calldata error) external pure; |
| 1673 | |
| 1674 | /// Asserts that two `uint256` values are not equal. |
| 1675 | function assertNotEq(uint256 left, uint256 right) external pure; |
| 1676 | |
| 1677 | /// Asserts that two arrays of `address` values are not equal. |
| 1678 | function assertNotEq(address[] calldata left, address[] calldata right) external pure; |
| 1679 | |
| 1680 | /// Asserts that two arrays of `address` values are not equal and includes error message into revert string on failure. |
| 1681 | function assertNotEq(address[] calldata left, address[] calldata right, string calldata error) external pure; |
| 1682 | |
| 1683 | /// Asserts that two arrays of `bytes32` values are not equal. |
| 1684 | function assertNotEq(bytes32[] calldata left, bytes32[] calldata right) external pure; |
| 1685 | |
| 1686 | /// Asserts that two arrays of `bytes32` values are not equal and includes error message into revert string on failure. |
| 1687 | function assertNotEq(bytes32[] calldata left, bytes32[] calldata right, string calldata error) external pure; |
| 1688 | |
| 1689 | /// Asserts that two arrays of `string` values are not equal. |
| 1690 | function assertNotEq(string[] calldata left, string[] calldata right) external pure; |
| 1691 | |
| 1692 | /// Asserts that two arrays of `string` values are not equal and includes error message into revert string on failure. |
| 1693 | function assertNotEq(string[] calldata left, string[] calldata right, string calldata error) external pure; |
| 1694 | |
| 1695 | /// Asserts that two arrays of `bytes` values are not equal. |
| 1696 | function assertNotEq(bytes[] calldata left, bytes[] calldata right) external pure; |
| 1697 | |
| 1698 | /// Asserts that two arrays of `bytes` values are not equal and includes error message into revert string on failure. |
| 1699 | function assertNotEq(bytes[] calldata left, bytes[] calldata right, string calldata error) external pure; |
| 1700 | |
| 1701 | /// Asserts that two `uint256` values are not equal and includes error message into revert string on failure. |
| 1702 | function assertNotEq(uint256 left, uint256 right, string calldata error) external pure; |
| 1703 | |
| 1704 | /// Asserts that two `int256` values are not equal. |
| 1705 | function assertNotEq(int256 left, int256 right) external pure; |
| 1706 | |
| 1707 | /// Asserts that two `int256` values are not equal and includes error message into revert string on failure. |
| 1708 | function assertNotEq(int256 left, int256 right, string calldata error) external pure; |
| 1709 | |
| 1710 | /// Asserts that two `address` values are not equal. |
| 1711 | function assertNotEq(address left, address right) external pure; |
| 1712 | |
| 1713 | /// Asserts that two `address` values are not equal and includes error message into revert string on failure. |
| 1714 | function assertNotEq(address left, address right, string calldata error) external pure; |
| 1715 | |
| 1716 | /// Asserts that two `bytes32` values are not equal. |
| 1717 | function assertNotEq(bytes32 left, bytes32 right) external pure; |
| 1718 | |
| 1719 | /// Asserts that two `bytes32` values are not equal and includes error message into revert string on failure. |
| 1720 | function assertNotEq(bytes32 left, bytes32 right, string calldata error) external pure; |
| 1721 | |
| 1722 | /// Asserts that the given condition is true. |
| 1723 | function assertTrue(bool condition) external pure; |
| 1724 | |
| 1725 | /// Asserts that the given condition is true and includes error message into revert string on failure. |
| 1726 | function assertTrue(bool condition, string calldata error) external pure; |
| 1727 | |
| 1728 | /// If the condition is false, discard this run's fuzz inputs and generate new ones. |
| 1729 | function assume(bool condition) external pure; |
| 1730 | |
| 1731 | /// Discard this run's fuzz inputs and generate new ones if next call reverted. |
| 1732 | function assumeNoRevert() external pure; |
| 1733 | |
| 1734 | /// Discard this run's fuzz inputs and generate new ones if next call reverts with the potential revert parameters. |
| 1735 | function assumeNoRevert(PotentialRevert calldata potentialRevert) external pure; |
| 1736 | |
| 1737 | /// Discard this run's fuzz inputs and generate new ones if next call reverts with the any of the potential revert parameters. |
| 1738 | function assumeNoRevert(PotentialRevert[] calldata potentialReverts) external pure; |
| 1739 | |
| 1740 | /// Writes a breakpoint to jump to in the debugger. |
| 1741 | function breakpoint(string calldata char) external pure; |
| 1742 | |
| 1743 | /// Writes a conditional breakpoint to jump to in the debugger. |
| 1744 | function breakpoint(string calldata char, bool value) external pure; |
| 1745 | |
| 1746 | /// Returns true if the current Foundry version is greater than or equal to the given version. |
| 1747 | /// The given version string must be in the format `major.minor.patch`. |
| 1748 | /// This is equivalent to `foundryVersionCmp(version) >= 0`. |
| 1749 | function foundryVersionAtLeast(string calldata version) external view returns (bool); |
| 1750 | |
| 1751 | /// Compares the current Foundry version with the given version string. |
| 1752 | /// The given version string must be in the format `major.minor.patch`. |
| 1753 | /// Returns: |
| 1754 | /// -1 if current Foundry version is less than the given version |
| 1755 | /// 0 if current Foundry version equals the given version |
| 1756 | /// 1 if current Foundry version is greater than the given version |
| 1757 | /// This result can then be used with a comparison operator against `0`. |
| 1758 | /// For example, to check if the current Foundry version is greater than or equal to `1.0.0`: |
| 1759 | /// `if (foundryVersionCmp("1.0.0") >= 0) { ... }` |
| 1760 | function foundryVersionCmp(string calldata version) external view returns (int256); |
| 1761 | |
| 1762 | /// Returns a Chain struct for specific alias |
| 1763 | function getChain(string calldata chainAlias) external view returns (Chain memory chain); |
| 1764 | |
| 1765 | /// Returns a Chain struct for specific chainId |
| 1766 | function getChain(uint256 chainId) external view returns (Chain memory chain); |
| 1767 | |
| 1768 | /// Returns the Foundry version. |
| 1769 | /// Format: <cargo_version>-<tag>+<git_sha_short>.<unix_build_timestamp>.<profile> |
| 1770 | /// Sample output: 0.3.0-nightly+3cb96bde9b.1737036656.debug |
| 1771 | /// Note: Build timestamps may vary slightly across platforms due to separate CI jobs. |
| 1772 | /// For reliable version comparisons, use UNIX format (e.g., >= 1700000000) |
| 1773 | /// to compare timestamps while ignoring minor time differences. |
| 1774 | function getFoundryVersion() external view returns (string memory version); |
| 1775 | |
| 1776 | /// Returns the RPC url for the given alias. |
| 1777 | function rpcUrl(string calldata rpcAlias) external view returns (string memory json); |
| 1778 | |
| 1779 | /// Returns all rpc urls and their aliases as structs. |
| 1780 | function rpcUrlStructs() external view returns (Rpc[] memory urls); |
| 1781 | |
| 1782 | /// Returns all rpc urls and their aliases `[alias, url][]`. |
| 1783 | function rpcUrls() external view returns (string[2][] memory urls); |
| 1784 | |
| 1785 | /// Suspends execution of the main thread for `duration` milliseconds. |
| 1786 | function sleep(uint256 duration) external; |
| 1787 | |
| 1788 | // ======== Toml ======== |
| 1789 | |
| 1790 | /// Checks if `key` exists in a TOML table. |
| 1791 | function keyExistsToml(string calldata toml, string calldata key) external view returns (bool); |
| 1792 | |
| 1793 | /// Parses a string of TOML data at `key` and coerces it to `address`. |
| 1794 | function parseTomlAddress(string calldata toml, string calldata key) external pure returns (address); |
| 1795 | |
| 1796 | /// Parses a string of TOML data at `key` and coerces it to `address[]`. |
| 1797 | function parseTomlAddressArray(string calldata toml, string calldata key) external pure returns (address[] memory); |
| 1798 | |
| 1799 | /// Parses a string of TOML data at `key` and coerces it to `bool`. |
| 1800 | function parseTomlBool(string calldata toml, string calldata key) external pure returns (bool); |
| 1801 | |
| 1802 | /// Parses a string of TOML data at `key` and coerces it to `bool[]`. |
| 1803 | function parseTomlBoolArray(string calldata toml, string calldata key) external pure returns (bool[] memory); |
| 1804 | |
| 1805 | /// Parses a string of TOML data at `key` and coerces it to `bytes`. |
| 1806 | function parseTomlBytes(string calldata toml, string calldata key) external pure returns (bytes memory); |
| 1807 | |
| 1808 | /// Parses a string of TOML data at `key` and coerces it to `bytes32`. |
| 1809 | function parseTomlBytes32(string calldata toml, string calldata key) external pure returns (bytes32); |
| 1810 | |
| 1811 | /// Parses a string of TOML data at `key` and coerces it to `bytes32[]`. |
| 1812 | function parseTomlBytes32Array(string calldata toml, string calldata key) external pure returns (bytes32[] memory); |
| 1813 | |
| 1814 | /// Parses a string of TOML data at `key` and coerces it to `bytes[]`. |
| 1815 | function parseTomlBytesArray(string calldata toml, string calldata key) external pure returns (bytes[] memory); |
| 1816 | |
| 1817 | /// Parses a string of TOML data at `key` and coerces it to `int256`. |
| 1818 | function parseTomlInt(string calldata toml, string calldata key) external pure returns (int256); |
| 1819 | |
| 1820 | /// Parses a string of TOML data at `key` and coerces it to `int256[]`. |
| 1821 | function parseTomlIntArray(string calldata toml, string calldata key) external pure returns (int256[] memory); |
| 1822 | |
| 1823 | /// Returns an array of all the keys in a TOML table. |
| 1824 | function parseTomlKeys(string calldata toml, string calldata key) external pure returns (string[] memory keys); |
| 1825 | |
| 1826 | /// Parses a string of TOML data at `key` and coerces it to `string`. |
| 1827 | function parseTomlString(string calldata toml, string calldata key) external pure returns (string memory); |
| 1828 | |
| 1829 | /// Parses a string of TOML data at `key` and coerces it to `string[]`. |
| 1830 | function parseTomlStringArray(string calldata toml, string calldata key) external pure returns (string[] memory); |
| 1831 | |
| 1832 | /// Parses a string of TOML data at `key` and coerces it to type array corresponding to `typeDescription`. |
| 1833 | function parseTomlTypeArray(string calldata toml, string calldata key, string calldata typeDescription) |
| 1834 | external |
| 1835 | pure |
| 1836 | returns (bytes memory); |
| 1837 | |
| 1838 | /// Parses a string of TOML data and coerces it to type corresponding to `typeDescription`. |
| 1839 | function parseTomlType(string calldata toml, string calldata typeDescription) external pure returns (bytes memory); |
| 1840 | |
| 1841 | /// Parses a string of TOML data at `key` and coerces it to type corresponding to `typeDescription`. |
| 1842 | function parseTomlType(string calldata toml, string calldata key, string calldata typeDescription) |
| 1843 | external |
| 1844 | pure |
| 1845 | returns (bytes memory); |
| 1846 | |
| 1847 | /// Parses a string of TOML data at `key` and coerces it to `uint256`. |
| 1848 | function parseTomlUint(string calldata toml, string calldata key) external pure returns (uint256); |
| 1849 | |
| 1850 | /// Parses a string of TOML data at `key` and coerces it to `uint256[]`. |
| 1851 | function parseTomlUintArray(string calldata toml, string calldata key) external pure returns (uint256[] memory); |
| 1852 | |
| 1853 | /// ABI-encodes a TOML table. |
| 1854 | function parseToml(string calldata toml) external pure returns (bytes memory abiEncodedData); |
| 1855 | |
| 1856 | /// ABI-encodes a TOML table at `key`. |
| 1857 | function parseToml(string calldata toml, string calldata key) external pure returns (bytes memory abiEncodedData); |
| 1858 | |
| 1859 | /// Takes serialized JSON, converts to TOML and write a serialized TOML to a file. |
| 1860 | function writeToml(string calldata json, string calldata path) external; |
| 1861 | |
| 1862 | /// Takes serialized JSON, converts to TOML and write a serialized TOML table to an **existing** TOML file, replacing a value with key = <value_key.> |
| 1863 | /// This is useful to replace a specific value of a TOML file, without having to parse the entire thing. |
| 1864 | /// This cheatcode will create new keys if they didn't previously exist. |
| 1865 | function writeToml(string calldata json, string calldata path, string calldata valueKey) external; |
| 1866 | |
| 1867 | // ======== Utilities ======== |
| 1868 | |
| 1869 | /// Returns an uint256 value bounded in given range and different from the current one. |
| 1870 | function bound(uint256 current, uint256 min, uint256 max) external view returns (uint256); |
| 1871 | |
| 1872 | /// Returns an int256 value bounded in given range and different from the current one. |
| 1873 | function bound(int256 current, int256 min, int256 max) external view returns (int256); |
| 1874 | |
| 1875 | /// Compute the address of a contract created with CREATE2 using the given CREATE2 deployer. |
| 1876 | function computeCreate2Address(bytes32 salt, bytes32 initCodeHash, address deployer) external pure returns (address); |
| 1877 | |
| 1878 | /// Compute the address of a contract created with CREATE2 using the default CREATE2 deployer. |
| 1879 | function computeCreate2Address(bytes32 salt, bytes32 initCodeHash) external pure returns (address); |
| 1880 | |
| 1881 | /// Compute the address a contract will be deployed at for a given deployer address and nonce. |
| 1882 | function computeCreateAddress(address deployer, uint256 nonce) external pure returns (address); |
| 1883 | |
| 1884 | /// Utility cheatcode to copy storage of `from` contract to another `to` contract. |
| 1885 | function copyStorage(address from, address to) external; |
| 1886 | |
| 1887 | /// Generates the struct hash of the canonical EIP-712 type representation and its abi-encoded data. |
| 1888 | /// Supports 2 different inputs: |
| 1889 | /// 1. Name of the type (i.e. "PermitSingle"): |
| 1890 | /// * requires previous binding generation with `forge bind-json`. |
| 1891 | /// * bindings will be retrieved from the path configured in `foundry.toml`. |
| 1892 | /// 2. String representation of the type (i.e. "Foo(Bar bar) Bar(uint256 baz)"). |
| 1893 | /// * Note: the cheatcode will use the canonical type even if the input is malformated |
| 1894 | /// with the wrong order of elements or with extra whitespaces. |
| 1895 | function eip712HashStruct(string calldata typeNameOrDefinition, bytes calldata abiEncodedData) |
| 1896 | external |
| 1897 | pure |
| 1898 | returns (bytes32 typeHash); |
| 1899 | |
| 1900 | /// Generates the struct hash of the canonical EIP-712 type representation and its abi-encoded data. |
| 1901 | /// Requires previous binding generation with `forge bind-json`. |
| 1902 | /// Params: |
| 1903 | /// * `bindingsPath`: path where the output of `forge bind-json` is stored. |
| 1904 | /// * `typeName`: Name of the type (i.e. "PermitSingle"). |
| 1905 | /// * `abiEncodedData`: ABI-encoded data for the struct that is being hashed. |
| 1906 | function eip712HashStruct(string calldata bindingsPath, string calldata typeName, bytes calldata abiEncodedData) |
| 1907 | external |
| 1908 | pure |
| 1909 | returns (bytes32 typeHash); |
| 1910 | |
| 1911 | /// Generates the hash of the canonical EIP-712 type representation. |
| 1912 | /// Supports 2 different inputs: |
| 1913 | /// 1. Name of the type (i.e. "Transaction"): |
| 1914 | /// * requires previous binding generation with `forge bind-json`. |
| 1915 | /// * bindings will be retrieved from the path configured in `foundry.toml`. |
| 1916 | /// 2. String representation of the type (i.e. "Foo(Bar bar) Bar(uint256 baz)"). |
| 1917 | /// * Note: the cheatcode will output the canonical type even if the input is malformated |
| 1918 | /// with the wrong order of elements or with extra whitespaces. |
| 1919 | function eip712HashType(string calldata typeNameOrDefinition) external pure returns (bytes32 typeHash); |
| 1920 | |
| 1921 | /// Generates the hash of the canonical EIP-712 type representation. |
| 1922 | /// Requires previous binding generation with `forge bind-json`. |
| 1923 | /// Params: |
| 1924 | /// * `bindingsPath`: path where the output of `forge bind-json` is stored. |
| 1925 | /// * `typeName`: Name of the type (i.e. "Transaction"). |
| 1926 | function eip712HashType(string calldata bindingsPath, string calldata typeName) |
| 1927 | external |
| 1928 | pure |
| 1929 | returns (bytes32 typeHash); |
| 1930 | |
| 1931 | /// Generates a ready-to-sign digest of human-readable typed data following the EIP-712 standard. |
| 1932 | function eip712HashTypedData(string calldata jsonData) external pure returns (bytes32 digest); |
| 1933 | |
| 1934 | /// Returns ENS namehash for provided string. |
| 1935 | function ensNamehash(string calldata name) external pure returns (bytes32); |
| 1936 | |
| 1937 | /// RLP decodes an RLP payload into a list of bytes. |
| 1938 | function fromRlp(bytes calldata rlp) external pure returns (bytes[] memory data); |
| 1939 | |
| 1940 | /// Gets the label for the specified address. |
| 1941 | function getLabel(address account) external view returns (string memory currentLabel); |
| 1942 | |
| 1943 | /// Labels an address in call traces. |
| 1944 | function label(address account, string calldata newLabel) external; |
| 1945 | |
| 1946 | /// Pauses collection of call traces. Useful in cases when you want to skip tracing of |
| 1947 | /// complex calls which are not useful for debugging. |
| 1948 | function pauseTracing() external view; |
| 1949 | |
| 1950 | /// Returns a random `address`. |
| 1951 | function randomAddress() external view returns (address); |
| 1952 | |
| 1953 | /// Returns a random `bool`. |
| 1954 | function randomBool() external view returns (bool); |
| 1955 | |
| 1956 | /// Returns a random byte array value of the given length. |
| 1957 | function randomBytes(uint256 len) external view returns (bytes memory); |
| 1958 | |
| 1959 | /// Returns a random fixed-size byte array of length 4. |
| 1960 | function randomBytes4() external view returns (bytes4); |
| 1961 | |
| 1962 | /// Returns a random fixed-size byte array of length 8. |
| 1963 | function randomBytes8() external view returns (bytes8); |
| 1964 | |
| 1965 | /// Returns a random `int256` value. |
| 1966 | function randomInt() external view returns (int256); |
| 1967 | |
| 1968 | /// Returns a random `int256` value of given bits. |
| 1969 | function randomInt(uint256 bits) external view returns (int256); |
| 1970 | |
| 1971 | /// Returns a random uint256 value. |
| 1972 | function randomUint() external view returns (uint256); |
| 1973 | |
| 1974 | /// Returns random uint256 value between the provided range (=min..=max). |
| 1975 | function randomUint(uint256 min, uint256 max) external view returns (uint256); |
| 1976 | |
| 1977 | /// Returns a random `uint256` value of given bits. |
| 1978 | function randomUint(uint256 bits) external view returns (uint256); |
| 1979 | |
| 1980 | /// Unpauses collection of call traces. |
| 1981 | function resumeTracing() external view; |
| 1982 | |
| 1983 | /// Utility cheatcode to set arbitrary storage for given target address. |
| 1984 | function setArbitraryStorage(address target) external; |
| 1985 | |
| 1986 | /// Utility cheatcode to set arbitrary storage for given target address and overwrite |
| 1987 | /// any storage slots that have been previously set. |
| 1988 | function setArbitraryStorage(address target, bool overwrite) external; |
| 1989 | |
| 1990 | /// Set RNG seed. |
| 1991 | function setSeed(uint256 seed) external; |
| 1992 | |
| 1993 | /// Randomly shuffles an array. |
| 1994 | function shuffle(uint256[] calldata array) external returns (uint256[] memory); |
| 1995 | |
| 1996 | /// Sorts an array in ascending order. |
| 1997 | function sort(uint256[] calldata array) external returns (uint256[] memory); |
| 1998 | |
| 1999 | /// Encodes a `bytes` value to a base64url string. |
| 2000 | function toBase64URL(bytes calldata data) external pure returns (string memory); |
| 2001 | |
| 2002 | /// Encodes a `string` value to a base64url string. |
| 2003 | function toBase64URL(string calldata data) external pure returns (string memory); |
| 2004 | |
| 2005 | /// Encodes a `bytes` value to a base64 string. |
| 2006 | function toBase64(bytes calldata data) external pure returns (string memory); |
| 2007 | |
| 2008 | /// Encodes a `string` value to a base64 string. |
| 2009 | function toBase64(string calldata data) external pure returns (string memory); |
| 2010 | |
| 2011 | /// RLP encodes a list of bytes into an RLP payload. |
| 2012 | function toRlp(bytes[] calldata data) external pure returns (bytes memory); |
| 2013 | } |
| 2014 | |
| 2015 | /// The `Vm` interface does allow manipulation of the EVM state. These are all intended to be used |
| 2016 | /// in tests, but it is not recommended to use these cheats in scripts. |
| 2017 | interface Vm is VmSafe { |
| 2018 | // ======== EVM ======== |
| 2019 | |
| 2020 | /// Utility cheatcode to set an EIP-2930 access list for all subsequent transactions. |
| 2021 | function accessList(AccessListItem[] calldata access) external; |
| 2022 | |
| 2023 | /// Returns the identifier of the currently active fork. Reverts if no fork is currently active. |
| 2024 | function activeFork() external view returns (uint256 forkId); |
| 2025 | |
| 2026 | /// In forking mode, explicitly grant the given address cheatcode access. |
| 2027 | function allowCheatcodes(address account) external; |
| 2028 | |
| 2029 | /// Sets `block.blobbasefee` |
| 2030 | function blobBaseFee(uint256 newBlobBaseFee) external; |
| 2031 | |
| 2032 | /// Sets the blobhashes in the transaction. |
| 2033 | /// Not available on EVM versions before Cancun. |
| 2034 | /// If used on unsupported EVM versions it will revert. |
| 2035 | function blobhashes(bytes32[] calldata hashes) external; |
| 2036 | |
| 2037 | /// Sets `block.chainid`. |
| 2038 | function chainId(uint256 newChainId) external; |
| 2039 | |
| 2040 | /// Clears all mocked calls. |
| 2041 | function clearMockedCalls() external; |
| 2042 | |
| 2043 | /// Clones a source account code, state, balance and nonce to a target account and updates in-memory EVM state. |
| 2044 | function cloneAccount(address source, address target) external; |
| 2045 | |
| 2046 | /// Sets `block.coinbase`. |
| 2047 | function coinbase(address newCoinbase) external; |
| 2048 | |
| 2049 | /// Marks the slots of an account and the account address as cold. |
| 2050 | function cool(address target) external; |
| 2051 | |
| 2052 | /// Utility cheatcode to mark specific storage slot as cold, simulating no prior read. |
| 2053 | function coolSlot(address target, bytes32 slot) external; |
| 2054 | |
| 2055 | /// Creates a new fork with the given endpoint and the _latest_ block and returns the identifier of the fork. |
| 2056 | function createFork(string calldata urlOrAlias) external returns (uint256 forkId); |
| 2057 | |
| 2058 | /// Creates a new fork with the given endpoint and block and returns the identifier of the fork. |
| 2059 | function createFork(string calldata urlOrAlias, uint256 blockNumber) external returns (uint256 forkId); |
| 2060 | |
| 2061 | /// Creates a new fork with the given endpoint and at the block the given transaction was mined in, |
| 2062 | /// replays all transaction mined in the block before the transaction, and returns the identifier of the fork. |
| 2063 | function createFork(string calldata urlOrAlias, bytes32 txHash) external returns (uint256 forkId); |
| 2064 | |
| 2065 | /// Creates and also selects a new fork with the given endpoint and the latest block and returns the identifier of the fork. |
| 2066 | function createSelectFork(string calldata urlOrAlias) external returns (uint256 forkId); |
| 2067 | |
| 2068 | /// Creates and also selects a new fork with the given endpoint and block and returns the identifier of the fork. |
| 2069 | function createSelectFork(string calldata urlOrAlias, uint256 blockNumber) external returns (uint256 forkId); |
| 2070 | |
| 2071 | /// Creates and also selects new fork with the given endpoint and at the block the given transaction was mined in, |
| 2072 | /// replays all transaction mined in the block before the transaction, returns the identifier of the fork. |
| 2073 | function createSelectFork(string calldata urlOrAlias, bytes32 txHash) external returns (uint256 forkId); |
| 2074 | |
| 2075 | /// Sets an address' balance. |
| 2076 | function deal(address account, uint256 newBalance) external; |
| 2077 | |
| 2078 | /// Removes the snapshot with the given ID created by `snapshot`. |
| 2079 | /// Takes the snapshot ID to delete. |
| 2080 | /// Returns `true` if the snapshot was successfully deleted. |
| 2081 | /// Returns `false` if the snapshot does not exist. |
| 2082 | function deleteStateSnapshot(uint256 snapshotId) external returns (bool success); |
| 2083 | |
| 2084 | /// Removes _all_ snapshots previously created by `snapshot`. |
| 2085 | function deleteStateSnapshots() external; |
| 2086 | |
| 2087 | /// Sets `block.difficulty`. |
| 2088 | /// Not available on EVM versions from Paris onwards. Use `prevrandao` instead. |
| 2089 | /// Reverts if used on unsupported EVM versions. |
| 2090 | function difficulty(uint256 newDifficulty) external; |
| 2091 | |
| 2092 | /// Dump a genesis JSON file's `allocs` to disk. |
| 2093 | function dumpState(string calldata pathToStateJson) external; |
| 2094 | |
| 2095 | /// Sets an address' code. |
| 2096 | function etch(address target, bytes calldata newRuntimeBytecode) external; |
| 2097 | |
| 2098 | /// Sets `block.basefee`. |
| 2099 | function fee(uint256 newBasefee) external; |
| 2100 | |
| 2101 | /// Gets the blockhashes from the current transaction. |
| 2102 | /// Not available on EVM versions before Cancun. |
| 2103 | /// If used on unsupported EVM versions it will revert. |
| 2104 | function getBlobhashes() external view returns (bytes32[] memory hashes); |
| 2105 | |
| 2106 | /// Returns true if the account is marked as persistent. |
| 2107 | function isPersistent(address account) external view returns (bool persistent); |
| 2108 | |
| 2109 | /// Load a genesis JSON file's `allocs` into the in-memory EVM state. |
| 2110 | function loadAllocs(string calldata pathToAllocsJson) external; |
| 2111 | |
| 2112 | /// Marks that the account(s) should use persistent storage across fork swaps in a multifork setup |
| 2113 | /// Meaning, changes made to the state of this account will be kept when switching forks. |
| 2114 | function makePersistent(address account) external; |
| 2115 | |
| 2116 | /// See `makePersistent(address)`. |
| 2117 | function makePersistent(address account0, address account1) external; |
| 2118 | |
| 2119 | /// See `makePersistent(address)`. |
| 2120 | function makePersistent(address account0, address account1, address account2) external; |
| 2121 | |
| 2122 | /// See `makePersistent(address)`. |
| 2123 | function makePersistent(address[] calldata accounts) external; |
| 2124 | |
| 2125 | /// Reverts a call to an address with specified revert data. |
| 2126 | function mockCallRevert(address callee, bytes calldata data, bytes calldata revertData) external; |
| 2127 | |
| 2128 | /// Reverts a call to an address with a specific `msg.value`, with specified revert data. |
| 2129 | function mockCallRevert(address callee, uint256 msgValue, bytes calldata data, bytes calldata revertData) external; |
| 2130 | |
| 2131 | /// Reverts a call to an address with specified revert data. |
| 2132 | /// Overload to pass the function selector directly `token.approve.selector` instead of `abi.encodeWithSelector(token.approve.selector)`. |
| 2133 | function mockCallRevert(address callee, bytes4 data, bytes calldata revertData) external; |
| 2134 | |
| 2135 | /// Reverts a call to an address with a specific `msg.value`, with specified revert data. |
| 2136 | /// Overload to pass the function selector directly `token.approve.selector` instead of `abi.encodeWithSelector(token.approve.selector)`. |
| 2137 | function mockCallRevert(address callee, uint256 msgValue, bytes4 data, bytes calldata revertData) external; |
| 2138 | |
| 2139 | /// Mocks a call to an address, returning specified data. |
| 2140 | /// Calldata can either be strict or a partial match, e.g. if you only |
| 2141 | /// pass a Solidity selector to the expected calldata, then the entire Solidity |
| 2142 | /// function will be mocked. |
| 2143 | function mockCall(address callee, bytes calldata data, bytes calldata returnData) external; |
| 2144 | |
| 2145 | /// Mocks a call to an address with a specific `msg.value`, returning specified data. |
| 2146 | /// Calldata match takes precedence over `msg.value` in case of ambiguity. |
| 2147 | function mockCall(address callee, uint256 msgValue, bytes calldata data, bytes calldata returnData) external; |
| 2148 | |
| 2149 | /// Mocks a call to an address, returning specified data. |
| 2150 | /// Calldata can either be strict or a partial match, e.g. if you only |
| 2151 | /// pass a Solidity selector to the expected calldata, then the entire Solidity |
| 2152 | /// function will be mocked. |
| 2153 | /// Overload to pass the function selector directly `token.approve.selector` instead of `abi.encodeWithSelector(token.approve.selector)`. |
| 2154 | function mockCall(address callee, bytes4 data, bytes calldata returnData) external; |
| 2155 | |
| 2156 | /// Mocks a call to an address with a specific `msg.value`, returning specified data. |
| 2157 | /// Calldata match takes precedence over `msg.value` in case of ambiguity. |
| 2158 | /// Overload to pass the function selector directly `token.approve.selector` instead of `abi.encodeWithSelector(token.approve.selector)`. |
| 2159 | function mockCall(address callee, uint256 msgValue, bytes4 data, bytes calldata returnData) external; |
| 2160 | |
| 2161 | /// Mocks multiple calls to an address, returning specified data for each call. |
| 2162 | function mockCalls(address callee, bytes calldata data, bytes[] calldata returnData) external; |
| 2163 | |
| 2164 | /// Mocks multiple calls to an address with a specific `msg.value`, returning specified data for each call. |
| 2165 | function mockCalls(address callee, uint256 msgValue, bytes calldata data, bytes[] calldata returnData) external; |
| 2166 | |
| 2167 | /// Whenever a call is made to `callee` with calldata `data`, this cheatcode instead calls |
| 2168 | /// `target` with the same calldata. This functionality is similar to a delegate call made to |
| 2169 | /// `target` contract from `callee`. |
| 2170 | /// Can be used to substitute a call to a function with another implementation that captures |
| 2171 | /// the primary logic of the original function but is easier to reason about. |
| 2172 | /// If calldata is not a strict match then partial match by selector is attempted. |
| 2173 | function mockFunction(address callee, address target, bytes calldata data) external; |
| 2174 | |
| 2175 | /// Utility cheatcode to remove any EIP-2930 access list set by `accessList` cheatcode. |
| 2176 | function noAccessList() external; |
| 2177 | |
| 2178 | /// Sets the *next* call's `msg.sender` to be the input address. |
| 2179 | function prank(address msgSender) external; |
| 2180 | |
| 2181 | /// Sets the *next* call's `msg.sender` to be the input address, and the `tx.origin` to be the second input. |
| 2182 | function prank(address msgSender, address txOrigin) external; |
| 2183 | |
| 2184 | /// Sets the *next* delegate call's `msg.sender` to be the input address. |
| 2185 | function prank(address msgSender, bool delegateCall) external; |
| 2186 | |
| 2187 | /// Sets the *next* delegate call's `msg.sender` to be the input address, and the `tx.origin` to be the second input. |
| 2188 | function prank(address msgSender, address txOrigin, bool delegateCall) external; |
| 2189 | |
| 2190 | /// Sets `block.prevrandao`. |
| 2191 | /// Not available on EVM versions before Paris. Use `difficulty` instead. |
| 2192 | /// If used on unsupported EVM versions it will revert. |
| 2193 | function prevrandao(bytes32 newPrevrandao) external; |
| 2194 | |
| 2195 | /// Sets `block.prevrandao`. |
| 2196 | /// Not available on EVM versions before Paris. Use `difficulty` instead. |
| 2197 | /// If used on unsupported EVM versions it will revert. |
| 2198 | function prevrandao(uint256 newPrevrandao) external; |
| 2199 | |
| 2200 | /// Reads the current `msg.sender` and `tx.origin` from state and reports if there is any active caller modification. |
| 2201 | function readCallers() external view returns (CallerMode callerMode, address msgSender, address txOrigin); |
| 2202 | |
| 2203 | /// Resets the nonce of an account to 0 for EOAs and 1 for contract accounts. |
| 2204 | function resetNonce(address account) external; |
| 2205 | |
| 2206 | /// Revert the state of the EVM to a previous snapshot |
| 2207 | /// Takes the snapshot ID to revert to. |
| 2208 | /// Returns `true` if the snapshot was successfully reverted. |
| 2209 | /// Returns `false` if the snapshot does not exist. |
| 2210 | /// **Note:** This does not automatically delete the snapshot. To delete the snapshot use `deleteStateSnapshot`. |
| 2211 | function revertToState(uint256 snapshotId) external returns (bool success); |
| 2212 | |
| 2213 | /// Revert the state of the EVM to a previous snapshot and automatically deletes the snapshots |
| 2214 | /// Takes the snapshot ID to revert to. |
| 2215 | /// Returns `true` if the snapshot was successfully reverted and deleted. |
| 2216 | /// Returns `false` if the snapshot does not exist. |
| 2217 | function revertToStateAndDelete(uint256 snapshotId) external returns (bool success); |
| 2218 | |
| 2219 | /// Revokes persistent status from the address, previously added via `makePersistent`. |
| 2220 | function revokePersistent(address account) external; |
| 2221 | |
| 2222 | /// See `revokePersistent(address)`. |
| 2223 | function revokePersistent(address[] calldata accounts) external; |
| 2224 | |
| 2225 | /// Sets `block.height`. |
| 2226 | function roll(uint256 newHeight) external; |
| 2227 | |
| 2228 | /// Updates the currently active fork to given block number |
| 2229 | /// This is similar to `roll` but for the currently active fork. |
| 2230 | function rollFork(uint256 blockNumber) external; |
| 2231 | |
| 2232 | /// Updates the currently active fork to given transaction. This will `rollFork` with the number |
| 2233 | /// of the block the transaction was mined in and replays all transaction mined before it in the block. |
| 2234 | function rollFork(bytes32 txHash) external; |
| 2235 | |
| 2236 | /// Updates the given fork to given block number. |
| 2237 | function rollFork(uint256 forkId, uint256 blockNumber) external; |
| 2238 | |
| 2239 | /// Updates the given fork to block number of the given transaction and replays all transaction mined before it in the block. |
| 2240 | function rollFork(uint256 forkId, bytes32 txHash) external; |
| 2241 | |
| 2242 | /// Takes a fork identifier created by `createFork` and sets the corresponding forked state as active. |
| 2243 | function selectFork(uint256 forkId) external; |
| 2244 | |
| 2245 | /// Set blockhash for the current block. |
| 2246 | /// It only sets the blockhash for blocks where `block.number - 256 <= number < block.number`. |
| 2247 | function setBlockhash(uint256 blockNumber, bytes32 blockHash) external; |
| 2248 | |
| 2249 | /// Sets the nonce of an account. Must be higher than the current nonce of the account. |
| 2250 | function setNonce(address account, uint64 newNonce) external; |
| 2251 | |
| 2252 | /// Sets the nonce of an account to an arbitrary value. |
| 2253 | function setNonceUnsafe(address account, uint64 newNonce) external; |
| 2254 | |
| 2255 | /// Snapshot capture the gas usage of the last call by name from the callee perspective. |
| 2256 | function snapshotGasLastCall(string calldata name) external returns (uint256 gasUsed); |
| 2257 | |
| 2258 | /// Snapshot capture the gas usage of the last call by name in a group from the callee perspective. |
| 2259 | function snapshotGasLastCall(string calldata group, string calldata name) external returns (uint256 gasUsed); |
| 2260 | |
| 2261 | /// Snapshot the current state of the evm. |
| 2262 | /// Returns the ID of the snapshot that was created. |
| 2263 | /// To revert a snapshot use `revertToState`. |
| 2264 | function snapshotState() external returns (uint256 snapshotId); |
| 2265 | |
| 2266 | /// Snapshot capture an arbitrary numerical value by name. |
| 2267 | /// The group name is derived from the contract name. |
| 2268 | function snapshotValue(string calldata name, uint256 value) external; |
| 2269 | |
| 2270 | /// Snapshot capture an arbitrary numerical value by name in a group. |
| 2271 | function snapshotValue(string calldata group, string calldata name, uint256 value) external; |
| 2272 | |
| 2273 | /// Sets all subsequent calls' `msg.sender` to be the input address until `stopPrank` is called. |
| 2274 | function startPrank(address msgSender) external; |
| 2275 | |
| 2276 | /// Sets all subsequent calls' `msg.sender` to be the input address until `stopPrank` is called, and the `tx.origin` to be the second input. |
| 2277 | function startPrank(address msgSender, address txOrigin) external; |
| 2278 | |
| 2279 | /// Sets all subsequent delegate calls' `msg.sender` to be the input address until `stopPrank` is called. |
| 2280 | function startPrank(address msgSender, bool delegateCall) external; |
| 2281 | |
| 2282 | /// Sets all subsequent delegate calls' `msg.sender` to be the input address until `stopPrank` is called, and the `tx.origin` to be the second input. |
| 2283 | function startPrank(address msgSender, address txOrigin, bool delegateCall) external; |
| 2284 | |
| 2285 | /// Start a snapshot capture of the current gas usage by name. |
| 2286 | /// The group name is derived from the contract name. |
| 2287 | function startSnapshotGas(string calldata name) external; |
| 2288 | |
| 2289 | /// Start a snapshot capture of the current gas usage by name in a group. |
| 2290 | function startSnapshotGas(string calldata group, string calldata name) external; |
| 2291 | |
| 2292 | /// Resets subsequent calls' `msg.sender` to be `address(this)`. |
| 2293 | function stopPrank() external; |
| 2294 | |
| 2295 | /// Stop the snapshot capture of the current gas by latest snapshot name, capturing the gas used since the start. |
| 2296 | function stopSnapshotGas() external returns (uint256 gasUsed); |
| 2297 | |
| 2298 | /// Stop the snapshot capture of the current gas usage by name, capturing the gas used since the start. |
| 2299 | /// The group name is derived from the contract name. |
| 2300 | function stopSnapshotGas(string calldata name) external returns (uint256 gasUsed); |
| 2301 | |
| 2302 | /// Stop the snapshot capture of the current gas usage by name in a group, capturing the gas used since the start. |
| 2303 | function stopSnapshotGas(string calldata group, string calldata name) external returns (uint256 gasUsed); |
| 2304 | |
| 2305 | /// Stores a value to an address' storage slot. |
| 2306 | function store(address target, bytes32 slot, bytes32 value) external; |
| 2307 | |
| 2308 | /// Fetches the given transaction from the active fork and executes it on the current state. |
| 2309 | function transact(bytes32 txHash) external; |
| 2310 | |
| 2311 | /// Fetches the given transaction from the given fork and executes it on the current state. |
| 2312 | function transact(uint256 forkId, bytes32 txHash) external; |
| 2313 | |
| 2314 | /// Sets `tx.gasprice`. |
| 2315 | function txGasPrice(uint256 newGasPrice) external; |
| 2316 | |
| 2317 | /// Utility cheatcode to mark specific storage slot as warm, simulating a prior read. |
| 2318 | function warmSlot(address target, bytes32 slot) external; |
| 2319 | |
| 2320 | /// Sets `block.timestamp`. |
| 2321 | function warp(uint256 newTimestamp) external; |
| 2322 | |
| 2323 | /// `deleteSnapshot` is being deprecated in favor of `deleteStateSnapshot`. It will be removed in future versions. |
| 2324 | function deleteSnapshot(uint256 snapshotId) external returns (bool success); |
| 2325 | |
| 2326 | /// `deleteSnapshots` is being deprecated in favor of `deleteStateSnapshots`. It will be removed in future versions. |
| 2327 | function deleteSnapshots() external; |
| 2328 | |
| 2329 | /// `revertToAndDelete` is being deprecated in favor of `revertToStateAndDelete`. It will be removed in future versions. |
| 2330 | function revertToAndDelete(uint256 snapshotId) external returns (bool success); |
| 2331 | |
| 2332 | /// `revertTo` is being deprecated in favor of `revertToState`. It will be removed in future versions. |
| 2333 | function revertTo(uint256 snapshotId) external returns (bool success); |
| 2334 | |
| 2335 | /// `snapshot` is being deprecated in favor of `snapshotState`. It will be removed in future versions. |
| 2336 | function snapshot() external returns (uint256 snapshotId); |
| 2337 | |
| 2338 | // ======== Testing ======== |
| 2339 | |
| 2340 | /// Expect a call to an address with the specified `msg.value` and calldata, and a *minimum* amount of gas. |
| 2341 | function expectCallMinGas(address callee, uint256 msgValue, uint64 minGas, bytes calldata data) external; |
| 2342 | |
| 2343 | /// Expect given number of calls to an address with the specified `msg.value` and calldata, and a *minimum* amount of gas. |
| 2344 | function expectCallMinGas(address callee, uint256 msgValue, uint64 minGas, bytes calldata data, uint64 count) |
| 2345 | external; |
| 2346 | |
| 2347 | /// Expects a call to an address with the specified calldata. |
| 2348 | /// Calldata can either be a strict or a partial match. |
| 2349 | function expectCall(address callee, bytes calldata data) external; |
| 2350 | |
| 2351 | /// Expects given number of calls to an address with the specified calldata. |
| 2352 | function expectCall(address callee, bytes calldata data, uint64 count) external; |
| 2353 | |
| 2354 | /// Expects a call to an address with the specified `msg.value` and calldata. |
| 2355 | function expectCall(address callee, uint256 msgValue, bytes calldata data) external; |
| 2356 | |
| 2357 | /// Expects given number of calls to an address with the specified `msg.value` and calldata. |
| 2358 | function expectCall(address callee, uint256 msgValue, bytes calldata data, uint64 count) external; |
| 2359 | |
| 2360 | /// Expect a call to an address with the specified `msg.value`, gas, and calldata. |
| 2361 | function expectCall(address callee, uint256 msgValue, uint64 gas, bytes calldata data) external; |
| 2362 | |
| 2363 | /// Expects given number of calls to an address with the specified `msg.value`, gas, and calldata. |
| 2364 | function expectCall(address callee, uint256 msgValue, uint64 gas, bytes calldata data, uint64 count) external; |
| 2365 | |
| 2366 | /// Expects the deployment of the specified bytecode by the specified address using the CREATE opcode |
| 2367 | function expectCreate(bytes calldata bytecode, address deployer) external; |
| 2368 | |
| 2369 | /// Expects the deployment of the specified bytecode by the specified address using the CREATE2 opcode |
| 2370 | function expectCreate2(bytes calldata bytecode, address deployer) external; |
| 2371 | |
| 2372 | /// Prepare an expected anonymous log with (bool checkTopic1, bool checkTopic2, bool checkTopic3, bool checkData.). |
| 2373 | /// Call this function, then emit an anonymous event, then call a function. Internally after the call, we check if |
| 2374 | /// logs were emitted in the expected order with the expected topics and data (as specified by the booleans). |
| 2375 | function expectEmitAnonymous(bool checkTopic0, bool checkTopic1, bool checkTopic2, bool checkTopic3, bool checkData) |
| 2376 | external; |
| 2377 | |
| 2378 | /// Same as the previous method, but also checks supplied address against emitting contract. |
| 2379 | function expectEmitAnonymous( |
| 2380 | bool checkTopic0, |
| 2381 | bool checkTopic1, |
| 2382 | bool checkTopic2, |
| 2383 | bool checkTopic3, |
| 2384 | bool checkData, |
| 2385 | address emitter |
| 2386 | ) external; |
| 2387 | |
| 2388 | /// Prepare an expected anonymous log with all topic and data checks enabled. |
| 2389 | /// Call this function, then emit an anonymous event, then call a function. Internally after the call, we check if |
| 2390 | /// logs were emitted in the expected order with the expected topics and data. |
| 2391 | function expectEmitAnonymous() external; |
| 2392 | |
| 2393 | /// Same as the previous method, but also checks supplied address against emitting contract. |
| 2394 | function expectEmitAnonymous(address emitter) external; |
| 2395 | |
| 2396 | /// Prepare an expected log with (bool checkTopic1, bool checkTopic2, bool checkTopic3, bool checkData.). |
| 2397 | /// Call this function, then emit an event, then call a function. Internally after the call, we check if |
| 2398 | /// logs were emitted in the expected order with the expected topics and data (as specified by the booleans). |
| 2399 | function expectEmit(bool checkTopic1, bool checkTopic2, bool checkTopic3, bool checkData) external; |
| 2400 | |
| 2401 | /// Same as the previous method, but also checks supplied address against emitting contract. |
| 2402 | function expectEmit(bool checkTopic1, bool checkTopic2, bool checkTopic3, bool checkData, address emitter) external; |
| 2403 | |
| 2404 | /// Prepare an expected log with all topic and data checks enabled. |
| 2405 | /// Call this function, then emit an event, then call a function. Internally after the call, we check if |
| 2406 | /// logs were emitted in the expected order with the expected topics and data. |
| 2407 | function expectEmit() external; |
| 2408 | |
| 2409 | /// Same as the previous method, but also checks supplied address against emitting contract. |
| 2410 | function expectEmit(address emitter) external; |
| 2411 | |
| 2412 | /// Expect a given number of logs with the provided topics. |
| 2413 | function expectEmit(bool checkTopic1, bool checkTopic2, bool checkTopic3, bool checkData, uint64 count) external; |
| 2414 | |
| 2415 | /// Expect a given number of logs from a specific emitter with the provided topics. |
| 2416 | function expectEmit( |
| 2417 | bool checkTopic1, |
| 2418 | bool checkTopic2, |
| 2419 | bool checkTopic3, |
| 2420 | bool checkData, |
| 2421 | address emitter, |
| 2422 | uint64 count |
| 2423 | ) external; |
| 2424 | |
| 2425 | /// Expect a given number of logs with all topic and data checks enabled. |
| 2426 | function expectEmit(uint64 count) external; |
| 2427 | |
| 2428 | /// Expect a given number of logs from a specific emitter with all topic and data checks enabled. |
| 2429 | function expectEmit(address emitter, uint64 count) external; |
| 2430 | |
| 2431 | /// Expects an error on next call that starts with the revert data. |
| 2432 | function expectPartialRevert(bytes4 revertData) external; |
| 2433 | |
| 2434 | /// Expects an error on next call to reverter address, that starts with the revert data. |
| 2435 | function expectPartialRevert(bytes4 revertData, address reverter) external; |
| 2436 | |
| 2437 | /// Expects an error on next call with any revert data. |
| 2438 | function expectRevert() external; |
| 2439 | |
| 2440 | /// Expects an error on next call that exactly matches the revert data. |
| 2441 | function expectRevert(bytes4 revertData) external; |
| 2442 | |
| 2443 | /// Expects a `count` number of reverts from the upcoming calls from the reverter address that match the revert data. |
| 2444 | function expectRevert(bytes4 revertData, address reverter, uint64 count) external; |
| 2445 | |
| 2446 | /// Expects a `count` number of reverts from the upcoming calls from the reverter address that exactly match the revert data. |
| 2447 | function expectRevert(bytes calldata revertData, address reverter, uint64 count) external; |
| 2448 | |
| 2449 | /// Expects an error on next call that exactly matches the revert data. |
| 2450 | function expectRevert(bytes calldata revertData) external; |
| 2451 | |
| 2452 | /// Expects an error with any revert data on next call to reverter address. |
| 2453 | function expectRevert(address reverter) external; |
| 2454 | |
| 2455 | /// Expects an error from reverter address on next call, with any revert data. |
| 2456 | function expectRevert(bytes4 revertData, address reverter) external; |
| 2457 | |
| 2458 | /// Expects an error from reverter address on next call, that exactly matches the revert data. |
| 2459 | function expectRevert(bytes calldata revertData, address reverter) external; |
| 2460 | |
| 2461 | /// Expects a `count` number of reverts from the upcoming calls with any revert data or reverter. |
| 2462 | function expectRevert(uint64 count) external; |
| 2463 | |
| 2464 | /// Expects a `count` number of reverts from the upcoming calls that match the revert data. |
| 2465 | function expectRevert(bytes4 revertData, uint64 count) external; |
| 2466 | |
| 2467 | /// Expects a `count` number of reverts from the upcoming calls that exactly match the revert data. |
| 2468 | function expectRevert(bytes calldata revertData, uint64 count) external; |
| 2469 | |
| 2470 | /// Expects a `count` number of reverts from the upcoming calls from the reverter address. |
| 2471 | function expectRevert(address reverter, uint64 count) external; |
| 2472 | |
| 2473 | /// Only allows memory writes to offsets [0x00, 0x60) ∪ [min, max) in the current subcontext. If any other |
| 2474 | /// memory is written to, the test will fail. Can be called multiple times to add more ranges to the set. |
| 2475 | function expectSafeMemory(uint64 min, uint64 max) external; |
| 2476 | |
| 2477 | /// Only allows memory writes to offsets [0x00, 0x60) ∪ [min, max) in the next created subcontext. |
| 2478 | /// If any other memory is written to, the test will fail. Can be called multiple times to add more ranges |
| 2479 | /// to the set. |
| 2480 | function expectSafeMemoryCall(uint64 min, uint64 max) external; |
| 2481 | |
| 2482 | /// Marks a test as skipped. Must be called at the top level of a test. |
| 2483 | function skip(bool skipTest) external; |
| 2484 | |
| 2485 | /// Marks a test as skipped with a reason. Must be called at the top level of a test. |
| 2486 | function skip(bool skipTest, string calldata reason) external; |
| 2487 | |
| 2488 | /// Stops all safe memory expectation in the current subcontext. |
| 2489 | function stopExpectSafeMemory() external; |
| 2490 | |
| 2491 | // ======== Utilities ======== |
| 2492 | |
| 2493 | /// Causes the next contract creation (via new) to fail and return its initcode in the returndata buffer. |
| 2494 | /// This allows type-safe access to the initcode payload that would be used for contract creation. |
| 2495 | /// Example usage: |
| 2496 | /// vm.interceptInitcode(); |
| 2497 | /// bytes memory initcode; |
| 2498 | /// try new MyContract(param1, param2) { assert(false); } |
| 2499 | /// catch (bytes memory interceptedInitcode) { initcode = interceptedInitcode; } |
| 2500 | function interceptInitcode() external; |
| 2501 | } |
| 2502 |
0.0%
lib/forge-std/src/console.sol
Lines covered: 0 / 4 (0.0%)
| 1 | // SPDX-License-Identifier: MIT |
| 2 | pragma solidity >=0.4.22 <0.9.0; |
| 3 | |
| 4 | library console { |
| 5 | address constant CONSOLE_ADDRESS = |
| 6 | 0x000000000000000000636F6e736F6c652e6c6f67; |
| 7 | |
| 8 | function _sendLogPayloadImplementation(bytes memory payload) internal view { |
| 9 | address consoleAddress = CONSOLE_ADDRESS; |
| 10 | /// @solidity memory-safe-assembly |
| 11 | assembly { |
| 12 | pop( |
| 13 | staticcall( |
| 14 | gas(), |
| 15 | consoleAddress, |
| 16 | add(payload, 32), |
| 17 | mload(payload), |
| 18 | 0, |
| 19 | 0 |
| 20 | ) |
| 21 | ) |
| 22 | } |
| 23 | } |
| 24 | |
| 25 | function _castToPure( |
| 26 | function(bytes memory) internal view fnIn |
| 27 | ) internal pure returns (function(bytes memory) pure fnOut) { |
| 28 | assembly { |
| 29 | fnOut := fnIn |
| 30 | } |
| 31 | } |
| 32 | |
| 33 | function _sendLogPayload(bytes memory payload) internal pure { |
| 34 | _castToPure(_sendLogPayloadImplementation)(payload); |
| 35 | } |
| 36 | |
| 37 | function log() internal pure { |
| 38 | _sendLogPayload(abi.encodeWithSignature("log()")); |
| 39 | } |
| 40 | |
| 41 | function logInt(int256 p0) internal pure { |
| 42 | _sendLogPayload(abi.encodeWithSignature("log(int256)", p0)); |
| 43 | } |
| 44 | |
| 45 | function logUint(uint256 p0) internal pure { |
| 46 | _sendLogPayload(abi.encodeWithSignature("log(uint256)", p0)); |
| 47 | } |
| 48 | |
| 49 | function logString(string memory p0) internal pure { |
| 50 | _sendLogPayload(abi.encodeWithSignature("log(string)", p0)); |
| 51 | } |
| 52 | |
| 53 | function logBool(bool p0) internal pure { |
| 54 | _sendLogPayload(abi.encodeWithSignature("log(bool)", p0)); |
| 55 | } |
| 56 | |
| 57 | function logAddress(address p0) internal pure { |
| 58 | _sendLogPayload(abi.encodeWithSignature("log(address)", p0)); |
| 59 | } |
| 60 | |
| 61 | function logBytes(bytes memory p0) internal pure { |
| 62 | _sendLogPayload(abi.encodeWithSignature("log(bytes)", p0)); |
| 63 | } |
| 64 | |
| 65 | function logBytes1(bytes1 p0) internal pure { |
| 66 | _sendLogPayload(abi.encodeWithSignature("log(bytes1)", p0)); |
| 67 | } |
| 68 | |
| 69 | function logBytes2(bytes2 p0) internal pure { |
| 70 | _sendLogPayload(abi.encodeWithSignature("log(bytes2)", p0)); |
| 71 | } |
| 72 | |
| 73 | function logBytes3(bytes3 p0) internal pure { |
| 74 | _sendLogPayload(abi.encodeWithSignature("log(bytes3)", p0)); |
| 75 | } |
| 76 | |
| 77 | function logBytes4(bytes4 p0) internal pure { |
| 78 | _sendLogPayload(abi.encodeWithSignature("log(bytes4)", p0)); |
| 79 | } |
| 80 | |
| 81 | function logBytes5(bytes5 p0) internal pure { |
| 82 | _sendLogPayload(abi.encodeWithSignature("log(bytes5)", p0)); |
| 83 | } |
| 84 | |
| 85 | function logBytes6(bytes6 p0) internal pure { |
| 86 | _sendLogPayload(abi.encodeWithSignature("log(bytes6)", p0)); |
| 87 | } |
| 88 | |
| 89 | function logBytes7(bytes7 p0) internal pure { |
| 90 | _sendLogPayload(abi.encodeWithSignature("log(bytes7)", p0)); |
| 91 | } |
| 92 | |
| 93 | function logBytes8(bytes8 p0) internal pure { |
| 94 | _sendLogPayload(abi.encodeWithSignature("log(bytes8)", p0)); |
| 95 | } |
| 96 | |
| 97 | function logBytes9(bytes9 p0) internal pure { |
| 98 | _sendLogPayload(abi.encodeWithSignature("log(bytes9)", p0)); |
| 99 | } |
| 100 | |
| 101 | function logBytes10(bytes10 p0) internal pure { |
| 102 | _sendLogPayload(abi.encodeWithSignature("log(bytes10)", p0)); |
| 103 | } |
| 104 | |
| 105 | function logBytes11(bytes11 p0) internal pure { |
| 106 | _sendLogPayload(abi.encodeWithSignature("log(bytes11)", p0)); |
| 107 | } |
| 108 | |
| 109 | function logBytes12(bytes12 p0) internal pure { |
| 110 | _sendLogPayload(abi.encodeWithSignature("log(bytes12)", p0)); |
| 111 | } |
| 112 | |
| 113 | function logBytes13(bytes13 p0) internal pure { |
| 114 | _sendLogPayload(abi.encodeWithSignature("log(bytes13)", p0)); |
| 115 | } |
| 116 | |
| 117 | function logBytes14(bytes14 p0) internal pure { |
| 118 | _sendLogPayload(abi.encodeWithSignature("log(bytes14)", p0)); |
| 119 | } |
| 120 | |
| 121 | function logBytes15(bytes15 p0) internal pure { |
| 122 | _sendLogPayload(abi.encodeWithSignature("log(bytes15)", p0)); |
| 123 | } |
| 124 | |
| 125 | function logBytes16(bytes16 p0) internal pure { |
| 126 | _sendLogPayload(abi.encodeWithSignature("log(bytes16)", p0)); |
| 127 | } |
| 128 | |
| 129 | function logBytes17(bytes17 p0) internal pure { |
| 130 | _sendLogPayload(abi.encodeWithSignature("log(bytes17)", p0)); |
| 131 | } |
| 132 | |
| 133 | function logBytes18(bytes18 p0) internal pure { |
| 134 | _sendLogPayload(abi.encodeWithSignature("log(bytes18)", p0)); |
| 135 | } |
| 136 | |
| 137 | function logBytes19(bytes19 p0) internal pure { |
| 138 | _sendLogPayload(abi.encodeWithSignature("log(bytes19)", p0)); |
| 139 | } |
| 140 | |
| 141 | function logBytes20(bytes20 p0) internal pure { |
| 142 | _sendLogPayload(abi.encodeWithSignature("log(bytes20)", p0)); |
| 143 | } |
| 144 | |
| 145 | function logBytes21(bytes21 p0) internal pure { |
| 146 | _sendLogPayload(abi.encodeWithSignature("log(bytes21)", p0)); |
| 147 | } |
| 148 | |
| 149 | function logBytes22(bytes22 p0) internal pure { |
| 150 | _sendLogPayload(abi.encodeWithSignature("log(bytes22)", p0)); |
| 151 | } |
| 152 | |
| 153 | function logBytes23(bytes23 p0) internal pure { |
| 154 | _sendLogPayload(abi.encodeWithSignature("log(bytes23)", p0)); |
| 155 | } |
| 156 | |
| 157 | function logBytes24(bytes24 p0) internal pure { |
| 158 | _sendLogPayload(abi.encodeWithSignature("log(bytes24)", p0)); |
| 159 | } |
| 160 | |
| 161 | function logBytes25(bytes25 p0) internal pure { |
| 162 | _sendLogPayload(abi.encodeWithSignature("log(bytes25)", p0)); |
| 163 | } |
| 164 | |
| 165 | function logBytes26(bytes26 p0) internal pure { |
| 166 | _sendLogPayload(abi.encodeWithSignature("log(bytes26)", p0)); |
| 167 | } |
| 168 | |
| 169 | function logBytes27(bytes27 p0) internal pure { |
| 170 | _sendLogPayload(abi.encodeWithSignature("log(bytes27)", p0)); |
| 171 | } |
| 172 | |
| 173 | function logBytes28(bytes28 p0) internal pure { |
| 174 | _sendLogPayload(abi.encodeWithSignature("log(bytes28)", p0)); |
| 175 | } |
| 176 | |
| 177 | function logBytes29(bytes29 p0) internal pure { |
| 178 | _sendLogPayload(abi.encodeWithSignature("log(bytes29)", p0)); |
| 179 | } |
| 180 | |
| 181 | function logBytes30(bytes30 p0) internal pure { |
| 182 | _sendLogPayload(abi.encodeWithSignature("log(bytes30)", p0)); |
| 183 | } |
| 184 | |
| 185 | function logBytes31(bytes31 p0) internal pure { |
| 186 | _sendLogPayload(abi.encodeWithSignature("log(bytes31)", p0)); |
| 187 | } |
| 188 | |
| 189 | function logBytes32(bytes32 p0) internal pure { |
| 190 | _sendLogPayload(abi.encodeWithSignature("log(bytes32)", p0)); |
| 191 | } |
| 192 | |
| 193 | function log(uint256 p0) internal pure { |
| 194 | _sendLogPayload(abi.encodeWithSignature("log(uint256)", p0)); |
| 195 | } |
| 196 | |
| 197 | function log(int256 p0) internal pure { |
| 198 | _sendLogPayload(abi.encodeWithSignature("log(int256)", p0)); |
| 199 | } |
| 200 | |
| 201 | function log(string memory p0) internal pure { |
| 202 | _sendLogPayload(abi.encodeWithSignature("log(string)", p0)); |
| 203 | } |
| 204 | |
| 205 | function log(bool p0) internal pure { |
| 206 | _sendLogPayload(abi.encodeWithSignature("log(bool)", p0)); |
| 207 | } |
| 208 | |
| 209 | function log(address p0) internal pure { |
| 210 | _sendLogPayload(abi.encodeWithSignature("log(address)", p0)); |
| 211 | } |
| 212 | |
| 213 | function log(uint256 p0, uint256 p1) internal pure { |
| 214 | _sendLogPayload(abi.encodeWithSignature("log(uint256,uint256)", p0, p1)); |
| 215 | } |
| 216 | |
| 217 | function log(uint256 p0, string memory p1) internal pure { |
| 218 | _sendLogPayload(abi.encodeWithSignature("log(uint256,string)", p0, p1)); |
| 219 | } |
| 220 | |
| 221 | function log(uint256 p0, bool p1) internal pure { |
| 222 | _sendLogPayload(abi.encodeWithSignature("log(uint256,bool)", p0, p1)); |
| 223 | } |
| 224 | |
| 225 | function log(uint256 p0, address p1) internal pure { |
| 226 | _sendLogPayload(abi.encodeWithSignature("log(uint256,address)", p0, p1)); |
| 227 | } |
| 228 | |
| 229 | function log(string memory p0, uint256 p1) internal pure { |
| 230 | _sendLogPayload(abi.encodeWithSignature("log(string,uint256)", p0, p1)); |
| 231 | } |
| 232 | |
| 233 | function log(string memory p0, int256 p1) internal pure { |
| 234 | _sendLogPayload(abi.encodeWithSignature("log(string,int256)", p0, p1)); |
| 235 | } |
| 236 | |
| 237 | function log(string memory p0, string memory p1) internal pure { |
| 238 | _sendLogPayload(abi.encodeWithSignature("log(string,string)", p0, p1)); |
| 239 | } |
| 240 | |
| 241 | function log(string memory p0, bool p1) internal pure { |
| 242 | _sendLogPayload(abi.encodeWithSignature("log(string,bool)", p0, p1)); |
| 243 | } |
| 244 | |
| 245 | function log(string memory p0, address p1) internal pure { |
| 246 | _sendLogPayload(abi.encodeWithSignature("log(string,address)", p0, p1)); |
| 247 | } |
| 248 | |
| 249 | function log(bool p0, uint256 p1) internal pure { |
| 250 | _sendLogPayload(abi.encodeWithSignature("log(bool,uint256)", p0, p1)); |
| 251 | } |
| 252 | |
| 253 | function log(bool p0, string memory p1) internal pure { |
| 254 | _sendLogPayload(abi.encodeWithSignature("log(bool,string)", p0, p1)); |
| 255 | } |
| 256 | |
| 257 | function log(bool p0, bool p1) internal pure { |
| 258 | _sendLogPayload(abi.encodeWithSignature("log(bool,bool)", p0, p1)); |
| 259 | } |
| 260 | |
| 261 | function log(bool p0, address p1) internal pure { |
| 262 | _sendLogPayload(abi.encodeWithSignature("log(bool,address)", p0, p1)); |
| 263 | } |
| 264 | |
| 265 | function log(address p0, uint256 p1) internal pure { |
| 266 | _sendLogPayload(abi.encodeWithSignature("log(address,uint256)", p0, p1)); |
| 267 | } |
| 268 | |
| 269 | function log(address p0, string memory p1) internal pure { |
| 270 | _sendLogPayload(abi.encodeWithSignature("log(address,string)", p0, p1)); |
| 271 | } |
| 272 | |
| 273 | function log(address p0, bool p1) internal pure { |
| 274 | _sendLogPayload(abi.encodeWithSignature("log(address,bool)", p0, p1)); |
| 275 | } |
| 276 | |
| 277 | function log(address p0, address p1) internal pure { |
| 278 | _sendLogPayload(abi.encodeWithSignature("log(address,address)", p0, p1)); |
| 279 | } |
| 280 | |
| 281 | function log(uint256 p0, uint256 p1, uint256 p2) internal pure { |
| 282 | _sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,uint256)", p0, p1, p2)); |
| 283 | } |
| 284 | |
| 285 | function log(uint256 p0, uint256 p1, string memory p2) internal pure { |
| 286 | _sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,string)", p0, p1, p2)); |
| 287 | } |
| 288 | |
| 289 | function log(uint256 p0, uint256 p1, bool p2) internal pure { |
| 290 | _sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,bool)", p0, p1, p2)); |
| 291 | } |
| 292 | |
| 293 | function log(uint256 p0, uint256 p1, address p2) internal pure { |
| 294 | _sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,address)", p0, p1, p2)); |
| 295 | } |
| 296 | |
| 297 | function log(uint256 p0, string memory p1, uint256 p2) internal pure { |
| 298 | _sendLogPayload(abi.encodeWithSignature("log(uint256,string,uint256)", p0, p1, p2)); |
| 299 | } |
| 300 | |
| 301 | function log(uint256 p0, string memory p1, string memory p2) internal pure { |
| 302 | _sendLogPayload(abi.encodeWithSignature("log(uint256,string,string)", p0, p1, p2)); |
| 303 | } |
| 304 | |
| 305 | function log(uint256 p0, string memory p1, bool p2) internal pure { |
| 306 | _sendLogPayload(abi.encodeWithSignature("log(uint256,string,bool)", p0, p1, p2)); |
| 307 | } |
| 308 | |
| 309 | function log(uint256 p0, string memory p1, address p2) internal pure { |
| 310 | _sendLogPayload(abi.encodeWithSignature("log(uint256,string,address)", p0, p1, p2)); |
| 311 | } |
| 312 | |
| 313 | function log(uint256 p0, bool p1, uint256 p2) internal pure { |
| 314 | _sendLogPayload(abi.encodeWithSignature("log(uint256,bool,uint256)", p0, p1, p2)); |
| 315 | } |
| 316 | |
| 317 | function log(uint256 p0, bool p1, string memory p2) internal pure { |
| 318 | _sendLogPayload(abi.encodeWithSignature("log(uint256,bool,string)", p0, p1, p2)); |
| 319 | } |
| 320 | |
| 321 | function log(uint256 p0, bool p1, bool p2) internal pure { |
| 322 | _sendLogPayload(abi.encodeWithSignature("log(uint256,bool,bool)", p0, p1, p2)); |
| 323 | } |
| 324 | |
| 325 | function log(uint256 p0, bool p1, address p2) internal pure { |
| 326 | _sendLogPayload(abi.encodeWithSignature("log(uint256,bool,address)", p0, p1, p2)); |
| 327 | } |
| 328 | |
| 329 | function log(uint256 p0, address p1, uint256 p2) internal pure { |
| 330 | _sendLogPayload(abi.encodeWithSignature("log(uint256,address,uint256)", p0, p1, p2)); |
| 331 | } |
| 332 | |
| 333 | function log(uint256 p0, address p1, string memory p2) internal pure { |
| 334 | _sendLogPayload(abi.encodeWithSignature("log(uint256,address,string)", p0, p1, p2)); |
| 335 | } |
| 336 | |
| 337 | function log(uint256 p0, address p1, bool p2) internal pure { |
| 338 | _sendLogPayload(abi.encodeWithSignature("log(uint256,address,bool)", p0, p1, p2)); |
| 339 | } |
| 340 | |
| 341 | function log(uint256 p0, address p1, address p2) internal pure { |
| 342 | _sendLogPayload(abi.encodeWithSignature("log(uint256,address,address)", p0, p1, p2)); |
| 343 | } |
| 344 | |
| 345 | function log(string memory p0, uint256 p1, uint256 p2) internal pure { |
| 346 | _sendLogPayload(abi.encodeWithSignature("log(string,uint256,uint256)", p0, p1, p2)); |
| 347 | } |
| 348 | |
| 349 | function log(string memory p0, uint256 p1, string memory p2) internal pure { |
| 350 | _sendLogPayload(abi.encodeWithSignature("log(string,uint256,string)", p0, p1, p2)); |
| 351 | } |
| 352 | |
| 353 | function log(string memory p0, uint256 p1, bool p2) internal pure { |
| 354 | _sendLogPayload(abi.encodeWithSignature("log(string,uint256,bool)", p0, p1, p2)); |
| 355 | } |
| 356 | |
| 357 | function log(string memory p0, uint256 p1, address p2) internal pure { |
| 358 | _sendLogPayload(abi.encodeWithSignature("log(string,uint256,address)", p0, p1, p2)); |
| 359 | } |
| 360 | |
| 361 | function log(string memory p0, string memory p1, uint256 p2) internal pure { |
| 362 | _sendLogPayload(abi.encodeWithSignature("log(string,string,uint256)", p0, p1, p2)); |
| 363 | } |
| 364 | |
| 365 | function log(string memory p0, string memory p1, string memory p2) internal pure { |
| 366 | _sendLogPayload(abi.encodeWithSignature("log(string,string,string)", p0, p1, p2)); |
| 367 | } |
| 368 | |
| 369 | function log(string memory p0, string memory p1, bool p2) internal pure { |
| 370 | _sendLogPayload(abi.encodeWithSignature("log(string,string,bool)", p0, p1, p2)); |
| 371 | } |
| 372 | |
| 373 | function log(string memory p0, string memory p1, address p2) internal pure { |
| 374 | _sendLogPayload(abi.encodeWithSignature("log(string,string,address)", p0, p1, p2)); |
| 375 | } |
| 376 | |
| 377 | function log(string memory p0, bool p1, uint256 p2) internal pure { |
| 378 | _sendLogPayload(abi.encodeWithSignature("log(string,bool,uint256)", p0, p1, p2)); |
| 379 | } |
| 380 | |
| 381 | function log(string memory p0, bool p1, string memory p2) internal pure { |
| 382 | _sendLogPayload(abi.encodeWithSignature("log(string,bool,string)", p0, p1, p2)); |
| 383 | } |
| 384 | |
| 385 | function log(string memory p0, bool p1, bool p2) internal pure { |
| 386 | _sendLogPayload(abi.encodeWithSignature("log(string,bool,bool)", p0, p1, p2)); |
| 387 | } |
| 388 | |
| 389 | function log(string memory p0, bool p1, address p2) internal pure { |
| 390 | _sendLogPayload(abi.encodeWithSignature("log(string,bool,address)", p0, p1, p2)); |
| 391 | } |
| 392 | |
| 393 | function log(string memory p0, address p1, uint256 p2) internal pure { |
| 394 | _sendLogPayload(abi.encodeWithSignature("log(string,address,uint256)", p0, p1, p2)); |
| 395 | } |
| 396 | |
| 397 | function log(string memory p0, address p1, string memory p2) internal pure { |
| 398 | _sendLogPayload(abi.encodeWithSignature("log(string,address,string)", p0, p1, p2)); |
| 399 | } |
| 400 | |
| 401 | function log(string memory p0, address p1, bool p2) internal pure { |
| 402 | _sendLogPayload(abi.encodeWithSignature("log(string,address,bool)", p0, p1, p2)); |
| 403 | } |
| 404 | |
| 405 | function log(string memory p0, address p1, address p2) internal pure { |
| 406 | _sendLogPayload(abi.encodeWithSignature("log(string,address,address)", p0, p1, p2)); |
| 407 | } |
| 408 | |
| 409 | function log(bool p0, uint256 p1, uint256 p2) internal pure { |
| 410 | _sendLogPayload(abi.encodeWithSignature("log(bool,uint256,uint256)", p0, p1, p2)); |
| 411 | } |
| 412 | |
| 413 | function log(bool p0, uint256 p1, string memory p2) internal pure { |
| 414 | _sendLogPayload(abi.encodeWithSignature("log(bool,uint256,string)", p0, p1, p2)); |
| 415 | } |
| 416 | |
| 417 | function log(bool p0, uint256 p1, bool p2) internal pure { |
| 418 | _sendLogPayload(abi.encodeWithSignature("log(bool,uint256,bool)", p0, p1, p2)); |
| 419 | } |
| 420 | |
| 421 | function log(bool p0, uint256 p1, address p2) internal pure { |
| 422 | _sendLogPayload(abi.encodeWithSignature("log(bool,uint256,address)", p0, p1, p2)); |
| 423 | } |
| 424 | |
| 425 | function log(bool p0, string memory p1, uint256 p2) internal pure { |
| 426 | _sendLogPayload(abi.encodeWithSignature("log(bool,string,uint256)", p0, p1, p2)); |
| 427 | } |
| 428 | |
| 429 | function log(bool p0, string memory p1, string memory p2) internal pure { |
| 430 | _sendLogPayload(abi.encodeWithSignature("log(bool,string,string)", p0, p1, p2)); |
| 431 | } |
| 432 | |
| 433 | function log(bool p0, string memory p1, bool p2) internal pure { |
| 434 | _sendLogPayload(abi.encodeWithSignature("log(bool,string,bool)", p0, p1, p2)); |
| 435 | } |
| 436 | |
| 437 | function log(bool p0, string memory p1, address p2) internal pure { |
| 438 | _sendLogPayload(abi.encodeWithSignature("log(bool,string,address)", p0, p1, p2)); |
| 439 | } |
| 440 | |
| 441 | function log(bool p0, bool p1, uint256 p2) internal pure { |
| 442 | _sendLogPayload(abi.encodeWithSignature("log(bool,bool,uint256)", p0, p1, p2)); |
| 443 | } |
| 444 | |
| 445 | function log(bool p0, bool p1, string memory p2) internal pure { |
| 446 | _sendLogPayload(abi.encodeWithSignature("log(bool,bool,string)", p0, p1, p2)); |
| 447 | } |
| 448 | |
| 449 | function log(bool p0, bool p1, bool p2) internal pure { |
| 450 | _sendLogPayload(abi.encodeWithSignature("log(bool,bool,bool)", p0, p1, p2)); |
| 451 | } |
| 452 | |
| 453 | function log(bool p0, bool p1, address p2) internal pure { |
| 454 | _sendLogPayload(abi.encodeWithSignature("log(bool,bool,address)", p0, p1, p2)); |
| 455 | } |
| 456 | |
| 457 | function log(bool p0, address p1, uint256 p2) internal pure { |
| 458 | _sendLogPayload(abi.encodeWithSignature("log(bool,address,uint256)", p0, p1, p2)); |
| 459 | } |
| 460 | |
| 461 | function log(bool p0, address p1, string memory p2) internal pure { |
| 462 | _sendLogPayload(abi.encodeWithSignature("log(bool,address,string)", p0, p1, p2)); |
| 463 | } |
| 464 | |
| 465 | function log(bool p0, address p1, bool p2) internal pure { |
| 466 | _sendLogPayload(abi.encodeWithSignature("log(bool,address,bool)", p0, p1, p2)); |
| 467 | } |
| 468 | |
| 469 | function log(bool p0, address p1, address p2) internal pure { |
| 470 | _sendLogPayload(abi.encodeWithSignature("log(bool,address,address)", p0, p1, p2)); |
| 471 | } |
| 472 | |
| 473 | function log(address p0, uint256 p1, uint256 p2) internal pure { |
| 474 | _sendLogPayload(abi.encodeWithSignature("log(address,uint256,uint256)", p0, p1, p2)); |
| 475 | } |
| 476 | |
| 477 | function log(address p0, uint256 p1, string memory p2) internal pure { |
| 478 | _sendLogPayload(abi.encodeWithSignature("log(address,uint256,string)", p0, p1, p2)); |
| 479 | } |
| 480 | |
| 481 | function log(address p0, uint256 p1, bool p2) internal pure { |
| 482 | _sendLogPayload(abi.encodeWithSignature("log(address,uint256,bool)", p0, p1, p2)); |
| 483 | } |
| 484 | |
| 485 | function log(address p0, uint256 p1, address p2) internal pure { |
| 486 | _sendLogPayload(abi.encodeWithSignature("log(address,uint256,address)", p0, p1, p2)); |
| 487 | } |
| 488 | |
| 489 | function log(address p0, string memory p1, uint256 p2) internal pure { |
| 490 | _sendLogPayload(abi.encodeWithSignature("log(address,string,uint256)", p0, p1, p2)); |
| 491 | } |
| 492 | |
| 493 | function log(address p0, string memory p1, string memory p2) internal pure { |
| 494 | _sendLogPayload(abi.encodeWithSignature("log(address,string,string)", p0, p1, p2)); |
| 495 | } |
| 496 | |
| 497 | function log(address p0, string memory p1, bool p2) internal pure { |
| 498 | _sendLogPayload(abi.encodeWithSignature("log(address,string,bool)", p0, p1, p2)); |
| 499 | } |
| 500 | |
| 501 | function log(address p0, string memory p1, address p2) internal pure { |
| 502 | _sendLogPayload(abi.encodeWithSignature("log(address,string,address)", p0, p1, p2)); |
| 503 | } |
| 504 | |
| 505 | function log(address p0, bool p1, uint256 p2) internal pure { |
| 506 | _sendLogPayload(abi.encodeWithSignature("log(address,bool,uint256)", p0, p1, p2)); |
| 507 | } |
| 508 | |
| 509 | function log(address p0, bool p1, string memory p2) internal pure { |
| 510 | _sendLogPayload(abi.encodeWithSignature("log(address,bool,string)", p0, p1, p2)); |
| 511 | } |
| 512 | |
| 513 | function log(address p0, bool p1, bool p2) internal pure { |
| 514 | _sendLogPayload(abi.encodeWithSignature("log(address,bool,bool)", p0, p1, p2)); |
| 515 | } |
| 516 | |
| 517 | function log(address p0, bool p1, address p2) internal pure { |
| 518 | _sendLogPayload(abi.encodeWithSignature("log(address,bool,address)", p0, p1, p2)); |
| 519 | } |
| 520 | |
| 521 | function log(address p0, address p1, uint256 p2) internal pure { |
| 522 | _sendLogPayload(abi.encodeWithSignature("log(address,address,uint256)", p0, p1, p2)); |
| 523 | } |
| 524 | |
| 525 | function log(address p0, address p1, string memory p2) internal pure { |
| 526 | _sendLogPayload(abi.encodeWithSignature("log(address,address,string)", p0, p1, p2)); |
| 527 | } |
| 528 | |
| 529 | function log(address p0, address p1, bool p2) internal pure { |
| 530 | _sendLogPayload(abi.encodeWithSignature("log(address,address,bool)", p0, p1, p2)); |
| 531 | } |
| 532 | |
| 533 | function log(address p0, address p1, address p2) internal pure { |
| 534 | _sendLogPayload(abi.encodeWithSignature("log(address,address,address)", p0, p1, p2)); |
| 535 | } |
| 536 | |
| 537 | function log(uint256 p0, uint256 p1, uint256 p2, uint256 p3) internal pure { |
| 538 | _sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,uint256,uint256)", p0, p1, p2, p3)); |
| 539 | } |
| 540 | |
| 541 | function log(uint256 p0, uint256 p1, uint256 p2, string memory p3) internal pure { |
| 542 | _sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,uint256,string)", p0, p1, p2, p3)); |
| 543 | } |
| 544 | |
| 545 | function log(uint256 p0, uint256 p1, uint256 p2, bool p3) internal pure { |
| 546 | _sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,uint256,bool)", p0, p1, p2, p3)); |
| 547 | } |
| 548 | |
| 549 | function log(uint256 p0, uint256 p1, uint256 p2, address p3) internal pure { |
| 550 | _sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,uint256,address)", p0, p1, p2, p3)); |
| 551 | } |
| 552 | |
| 553 | function log(uint256 p0, uint256 p1, string memory p2, uint256 p3) internal pure { |
| 554 | _sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,string,uint256)", p0, p1, p2, p3)); |
| 555 | } |
| 556 | |
| 557 | function log(uint256 p0, uint256 p1, string memory p2, string memory p3) internal pure { |
| 558 | _sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,string,string)", p0, p1, p2, p3)); |
| 559 | } |
| 560 | |
| 561 | function log(uint256 p0, uint256 p1, string memory p2, bool p3) internal pure { |
| 562 | _sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,string,bool)", p0, p1, p2, p3)); |
| 563 | } |
| 564 | |
| 565 | function log(uint256 p0, uint256 p1, string memory p2, address p3) internal pure { |
| 566 | _sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,string,address)", p0, p1, p2, p3)); |
| 567 | } |
| 568 | |
| 569 | function log(uint256 p0, uint256 p1, bool p2, uint256 p3) internal pure { |
| 570 | _sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,bool,uint256)", p0, p1, p2, p3)); |
| 571 | } |
| 572 | |
| 573 | function log(uint256 p0, uint256 p1, bool p2, string memory p3) internal pure { |
| 574 | _sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,bool,string)", p0, p1, p2, p3)); |
| 575 | } |
| 576 | |
| 577 | function log(uint256 p0, uint256 p1, bool p2, bool p3) internal pure { |
| 578 | _sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,bool,bool)", p0, p1, p2, p3)); |
| 579 | } |
| 580 | |
| 581 | function log(uint256 p0, uint256 p1, bool p2, address p3) internal pure { |
| 582 | _sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,bool,address)", p0, p1, p2, p3)); |
| 583 | } |
| 584 | |
| 585 | function log(uint256 p0, uint256 p1, address p2, uint256 p3) internal pure { |
| 586 | _sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,address,uint256)", p0, p1, p2, p3)); |
| 587 | } |
| 588 | |
| 589 | function log(uint256 p0, uint256 p1, address p2, string memory p3) internal pure { |
| 590 | _sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,address,string)", p0, p1, p2, p3)); |
| 591 | } |
| 592 | |
| 593 | function log(uint256 p0, uint256 p1, address p2, bool p3) internal pure { |
| 594 | _sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,address,bool)", p0, p1, p2, p3)); |
| 595 | } |
| 596 | |
| 597 | function log(uint256 p0, uint256 p1, address p2, address p3) internal pure { |
| 598 | _sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,address,address)", p0, p1, p2, p3)); |
| 599 | } |
| 600 | |
| 601 | function log(uint256 p0, string memory p1, uint256 p2, uint256 p3) internal pure { |
| 602 | _sendLogPayload(abi.encodeWithSignature("log(uint256,string,uint256,uint256)", p0, p1, p2, p3)); |
| 603 | } |
| 604 | |
| 605 | function log(uint256 p0, string memory p1, uint256 p2, string memory p3) internal pure { |
| 606 | _sendLogPayload(abi.encodeWithSignature("log(uint256,string,uint256,string)", p0, p1, p2, p3)); |
| 607 | } |
| 608 | |
| 609 | function log(uint256 p0, string memory p1, uint256 p2, bool p3) internal pure { |
| 610 | _sendLogPayload(abi.encodeWithSignature("log(uint256,string,uint256,bool)", p0, p1, p2, p3)); |
| 611 | } |
| 612 | |
| 613 | function log(uint256 p0, string memory p1, uint256 p2, address p3) internal pure { |
| 614 | _sendLogPayload(abi.encodeWithSignature("log(uint256,string,uint256,address)", p0, p1, p2, p3)); |
| 615 | } |
| 616 | |
| 617 | function log(uint256 p0, string memory p1, string memory p2, uint256 p3) internal pure { |
| 618 | _sendLogPayload(abi.encodeWithSignature("log(uint256,string,string,uint256)", p0, p1, p2, p3)); |
| 619 | } |
| 620 | |
| 621 | function log(uint256 p0, string memory p1, string memory p2, string memory p3) internal pure { |
| 622 | _sendLogPayload(abi.encodeWithSignature("log(uint256,string,string,string)", p0, p1, p2, p3)); |
| 623 | } |
| 624 | |
| 625 | function log(uint256 p0, string memory p1, string memory p2, bool p3) internal pure { |
| 626 | _sendLogPayload(abi.encodeWithSignature("log(uint256,string,string,bool)", p0, p1, p2, p3)); |
| 627 | } |
| 628 | |
| 629 | function log(uint256 p0, string memory p1, string memory p2, address p3) internal pure { |
| 630 | _sendLogPayload(abi.encodeWithSignature("log(uint256,string,string,address)", p0, p1, p2, p3)); |
| 631 | } |
| 632 | |
| 633 | function log(uint256 p0, string memory p1, bool p2, uint256 p3) internal pure { |
| 634 | _sendLogPayload(abi.encodeWithSignature("log(uint256,string,bool,uint256)", p0, p1, p2, p3)); |
| 635 | } |
| 636 | |
| 637 | function log(uint256 p0, string memory p1, bool p2, string memory p3) internal pure { |
| 638 | _sendLogPayload(abi.encodeWithSignature("log(uint256,string,bool,string)", p0, p1, p2, p3)); |
| 639 | } |
| 640 | |
| 641 | function log(uint256 p0, string memory p1, bool p2, bool p3) internal pure { |
| 642 | _sendLogPayload(abi.encodeWithSignature("log(uint256,string,bool,bool)", p0, p1, p2, p3)); |
| 643 | } |
| 644 | |
| 645 | function log(uint256 p0, string memory p1, bool p2, address p3) internal pure { |
| 646 | _sendLogPayload(abi.encodeWithSignature("log(uint256,string,bool,address)", p0, p1, p2, p3)); |
| 647 | } |
| 648 | |
| 649 | function log(uint256 p0, string memory p1, address p2, uint256 p3) internal pure { |
| 650 | _sendLogPayload(abi.encodeWithSignature("log(uint256,string,address,uint256)", p0, p1, p2, p3)); |
| 651 | } |
| 652 | |
| 653 | function log(uint256 p0, string memory p1, address p2, string memory p3) internal pure { |
| 654 | _sendLogPayload(abi.encodeWithSignature("log(uint256,string,address,string)", p0, p1, p2, p3)); |
| 655 | } |
| 656 | |
| 657 | function log(uint256 p0, string memory p1, address p2, bool p3) internal pure { |
| 658 | _sendLogPayload(abi.encodeWithSignature("log(uint256,string,address,bool)", p0, p1, p2, p3)); |
| 659 | } |
| 660 | |
| 661 | function log(uint256 p0, string memory p1, address p2, address p3) internal pure { |
| 662 | _sendLogPayload(abi.encodeWithSignature("log(uint256,string,address,address)", p0, p1, p2, p3)); |
| 663 | } |
| 664 | |
| 665 | function log(uint256 p0, bool p1, uint256 p2, uint256 p3) internal pure { |
| 666 | _sendLogPayload(abi.encodeWithSignature("log(uint256,bool,uint256,uint256)", p0, p1, p2, p3)); |
| 667 | } |
| 668 | |
| 669 | function log(uint256 p0, bool p1, uint256 p2, string memory p3) internal pure { |
| 670 | _sendLogPayload(abi.encodeWithSignature("log(uint256,bool,uint256,string)", p0, p1, p2, p3)); |
| 671 | } |
| 672 | |
| 673 | function log(uint256 p0, bool p1, uint256 p2, bool p3) internal pure { |
| 674 | _sendLogPayload(abi.encodeWithSignature("log(uint256,bool,uint256,bool)", p0, p1, p2, p3)); |
| 675 | } |
| 676 | |
| 677 | function log(uint256 p0, bool p1, uint256 p2, address p3) internal pure { |
| 678 | _sendLogPayload(abi.encodeWithSignature("log(uint256,bool,uint256,address)", p0, p1, p2, p3)); |
| 679 | } |
| 680 | |
| 681 | function log(uint256 p0, bool p1, string memory p2, uint256 p3) internal pure { |
| 682 | _sendLogPayload(abi.encodeWithSignature("log(uint256,bool,string,uint256)", p0, p1, p2, p3)); |
| 683 | } |
| 684 | |
| 685 | function log(uint256 p0, bool p1, string memory p2, string memory p3) internal pure { |
| 686 | _sendLogPayload(abi.encodeWithSignature("log(uint256,bool,string,string)", p0, p1, p2, p3)); |
| 687 | } |
| 688 | |
| 689 | function log(uint256 p0, bool p1, string memory p2, bool p3) internal pure { |
| 690 | _sendLogPayload(abi.encodeWithSignature("log(uint256,bool,string,bool)", p0, p1, p2, p3)); |
| 691 | } |
| 692 | |
| 693 | function log(uint256 p0, bool p1, string memory p2, address p3) internal pure { |
| 694 | _sendLogPayload(abi.encodeWithSignature("log(uint256,bool,string,address)", p0, p1, p2, p3)); |
| 695 | } |
| 696 | |
| 697 | function log(uint256 p0, bool p1, bool p2, uint256 p3) internal pure { |
| 698 | _sendLogPayload(abi.encodeWithSignature("log(uint256,bool,bool,uint256)", p0, p1, p2, p3)); |
| 699 | } |
| 700 | |
| 701 | function log(uint256 p0, bool p1, bool p2, string memory p3) internal pure { |
| 702 | _sendLogPayload(abi.encodeWithSignature("log(uint256,bool,bool,string)", p0, p1, p2, p3)); |
| 703 | } |
| 704 | |
| 705 | function log(uint256 p0, bool p1, bool p2, bool p3) internal pure { |
| 706 | _sendLogPayload(abi.encodeWithSignature("log(uint256,bool,bool,bool)", p0, p1, p2, p3)); |
| 707 | } |
| 708 | |
| 709 | function log(uint256 p0, bool p1, bool p2, address p3) internal pure { |
| 710 | _sendLogPayload(abi.encodeWithSignature("log(uint256,bool,bool,address)", p0, p1, p2, p3)); |
| 711 | } |
| 712 | |
| 713 | function log(uint256 p0, bool p1, address p2, uint256 p3) internal pure { |
| 714 | _sendLogPayload(abi.encodeWithSignature("log(uint256,bool,address,uint256)", p0, p1, p2, p3)); |
| 715 | } |
| 716 | |
| 717 | function log(uint256 p0, bool p1, address p2, string memory p3) internal pure { |
| 718 | _sendLogPayload(abi.encodeWithSignature("log(uint256,bool,address,string)", p0, p1, p2, p3)); |
| 719 | } |
| 720 | |
| 721 | function log(uint256 p0, bool p1, address p2, bool p3) internal pure { |
| 722 | _sendLogPayload(abi.encodeWithSignature("log(uint256,bool,address,bool)", p0, p1, p2, p3)); |
| 723 | } |
| 724 | |
| 725 | function log(uint256 p0, bool p1, address p2, address p3) internal pure { |
| 726 | _sendLogPayload(abi.encodeWithSignature("log(uint256,bool,address,address)", p0, p1, p2, p3)); |
| 727 | } |
| 728 | |
| 729 | function log(uint256 p0, address p1, uint256 p2, uint256 p3) internal pure { |
| 730 | _sendLogPayload(abi.encodeWithSignature("log(uint256,address,uint256,uint256)", p0, p1, p2, p3)); |
| 731 | } |
| 732 | |
| 733 | function log(uint256 p0, address p1, uint256 p2, string memory p3) internal pure { |
| 734 | _sendLogPayload(abi.encodeWithSignature("log(uint256,address,uint256,string)", p0, p1, p2, p3)); |
| 735 | } |
| 736 | |
| 737 | function log(uint256 p0, address p1, uint256 p2, bool p3) internal pure { |
| 738 | _sendLogPayload(abi.encodeWithSignature("log(uint256,address,uint256,bool)", p0, p1, p2, p3)); |
| 739 | } |
| 740 | |
| 741 | function log(uint256 p0, address p1, uint256 p2, address p3) internal pure { |
| 742 | _sendLogPayload(abi.encodeWithSignature("log(uint256,address,uint256,address)", p0, p1, p2, p3)); |
| 743 | } |
| 744 | |
| 745 | function log(uint256 p0, address p1, string memory p2, uint256 p3) internal pure { |
| 746 | _sendLogPayload(abi.encodeWithSignature("log(uint256,address,string,uint256)", p0, p1, p2, p3)); |
| 747 | } |
| 748 | |
| 749 | function log(uint256 p0, address p1, string memory p2, string memory p3) internal pure { |
| 750 | _sendLogPayload(abi.encodeWithSignature("log(uint256,address,string,string)", p0, p1, p2, p3)); |
| 751 | } |
| 752 | |
| 753 | function log(uint256 p0, address p1, string memory p2, bool p3) internal pure { |
| 754 | _sendLogPayload(abi.encodeWithSignature("log(uint256,address,string,bool)", p0, p1, p2, p3)); |
| 755 | } |
| 756 | |
| 757 | function log(uint256 p0, address p1, string memory p2, address p3) internal pure { |
| 758 | _sendLogPayload(abi.encodeWithSignature("log(uint256,address,string,address)", p0, p1, p2, p3)); |
| 759 | } |
| 760 | |
| 761 | function log(uint256 p0, address p1, bool p2, uint256 p3) internal pure { |
| 762 | _sendLogPayload(abi.encodeWithSignature("log(uint256,address,bool,uint256)", p0, p1, p2, p3)); |
| 763 | } |
| 764 | |
| 765 | function log(uint256 p0, address p1, bool p2, string memory p3) internal pure { |
| 766 | _sendLogPayload(abi.encodeWithSignature("log(uint256,address,bool,string)", p0, p1, p2, p3)); |
| 767 | } |
| 768 | |
| 769 | function log(uint256 p0, address p1, bool p2, bool p3) internal pure { |
| 770 | _sendLogPayload(abi.encodeWithSignature("log(uint256,address,bool,bool)", p0, p1, p2, p3)); |
| 771 | } |
| 772 | |
| 773 | function log(uint256 p0, address p1, bool p2, address p3) internal pure { |
| 774 | _sendLogPayload(abi.encodeWithSignature("log(uint256,address,bool,address)", p0, p1, p2, p3)); |
| 775 | } |
| 776 | |
| 777 | function log(uint256 p0, address p1, address p2, uint256 p3) internal pure { |
| 778 | _sendLogPayload(abi.encodeWithSignature("log(uint256,address,address,uint256)", p0, p1, p2, p3)); |
| 779 | } |
| 780 | |
| 781 | function log(uint256 p0, address p1, address p2, string memory p3) internal pure { |
| 782 | _sendLogPayload(abi.encodeWithSignature("log(uint256,address,address,string)", p0, p1, p2, p3)); |
| 783 | } |
| 784 | |
| 785 | function log(uint256 p0, address p1, address p2, bool p3) internal pure { |
| 786 | _sendLogPayload(abi.encodeWithSignature("log(uint256,address,address,bool)", p0, p1, p2, p3)); |
| 787 | } |
| 788 | |
| 789 | function log(uint256 p0, address p1, address p2, address p3) internal pure { |
| 790 | _sendLogPayload(abi.encodeWithSignature("log(uint256,address,address,address)", p0, p1, p2, p3)); |
| 791 | } |
| 792 | |
| 793 | function log(string memory p0, uint256 p1, uint256 p2, uint256 p3) internal pure { |
| 794 | _sendLogPayload(abi.encodeWithSignature("log(string,uint256,uint256,uint256)", p0, p1, p2, p3)); |
| 795 | } |
| 796 | |
| 797 | function log(string memory p0, uint256 p1, uint256 p2, string memory p3) internal pure { |
| 798 | _sendLogPayload(abi.encodeWithSignature("log(string,uint256,uint256,string)", p0, p1, p2, p3)); |
| 799 | } |
| 800 | |
| 801 | function log(string memory p0, uint256 p1, uint256 p2, bool p3) internal pure { |
| 802 | _sendLogPayload(abi.encodeWithSignature("log(string,uint256,uint256,bool)", p0, p1, p2, p3)); |
| 803 | } |
| 804 | |
| 805 | function log(string memory p0, uint256 p1, uint256 p2, address p3) internal pure { |
| 806 | _sendLogPayload(abi.encodeWithSignature("log(string,uint256,uint256,address)", p0, p1, p2, p3)); |
| 807 | } |
| 808 | |
| 809 | function log(string memory p0, uint256 p1, string memory p2, uint256 p3) internal pure { |
| 810 | _sendLogPayload(abi.encodeWithSignature("log(string,uint256,string,uint256)", p0, p1, p2, p3)); |
| 811 | } |
| 812 | |
| 813 | function log(string memory p0, uint256 p1, string memory p2, string memory p3) internal pure { |
| 814 | _sendLogPayload(abi.encodeWithSignature("log(string,uint256,string,string)", p0, p1, p2, p3)); |
| 815 | } |
| 816 | |
| 817 | function log(string memory p0, uint256 p1, string memory p2, bool p3) internal pure { |
| 818 | _sendLogPayload(abi.encodeWithSignature("log(string,uint256,string,bool)", p0, p1, p2, p3)); |
| 819 | } |
| 820 | |
| 821 | function log(string memory p0, uint256 p1, string memory p2, address p3) internal pure { |
| 822 | _sendLogPayload(abi.encodeWithSignature("log(string,uint256,string,address)", p0, p1, p2, p3)); |
| 823 | } |
| 824 | |
| 825 | function log(string memory p0, uint256 p1, bool p2, uint256 p3) internal pure { |
| 826 | _sendLogPayload(abi.encodeWithSignature("log(string,uint256,bool,uint256)", p0, p1, p2, p3)); |
| 827 | } |
| 828 | |
| 829 | function log(string memory p0, uint256 p1, bool p2, string memory p3) internal pure { |
| 830 | _sendLogPayload(abi.encodeWithSignature("log(string,uint256,bool,string)", p0, p1, p2, p3)); |
| 831 | } |
| 832 | |
| 833 | function log(string memory p0, uint256 p1, bool p2, bool p3) internal pure { |
| 834 | _sendLogPayload(abi.encodeWithSignature("log(string,uint256,bool,bool)", p0, p1, p2, p3)); |
| 835 | } |
| 836 | |
| 837 | function log(string memory p0, uint256 p1, bool p2, address p3) internal pure { |
| 838 | _sendLogPayload(abi.encodeWithSignature("log(string,uint256,bool,address)", p0, p1, p2, p3)); |
| 839 | } |
| 840 | |
| 841 | function log(string memory p0, uint256 p1, address p2, uint256 p3) internal pure { |
| 842 | _sendLogPayload(abi.encodeWithSignature("log(string,uint256,address,uint256)", p0, p1, p2, p3)); |
| 843 | } |
| 844 | |
| 845 | function log(string memory p0, uint256 p1, address p2, string memory p3) internal pure { |
| 846 | _sendLogPayload(abi.encodeWithSignature("log(string,uint256,address,string)", p0, p1, p2, p3)); |
| 847 | } |
| 848 | |
| 849 | function log(string memory p0, uint256 p1, address p2, bool p3) internal pure { |
| 850 | _sendLogPayload(abi.encodeWithSignature("log(string,uint256,address,bool)", p0, p1, p2, p3)); |
| 851 | } |
| 852 | |
| 853 | function log(string memory p0, uint256 p1, address p2, address p3) internal pure { |
| 854 | _sendLogPayload(abi.encodeWithSignature("log(string,uint256,address,address)", p0, p1, p2, p3)); |
| 855 | } |
| 856 | |
| 857 | function log(string memory p0, string memory p1, uint256 p2, uint256 p3) internal pure { |
| 858 | _sendLogPayload(abi.encodeWithSignature("log(string,string,uint256,uint256)", p0, p1, p2, p3)); |
| 859 | } |
| 860 | |
| 861 | function log(string memory p0, string memory p1, uint256 p2, string memory p3) internal pure { |
| 862 | _sendLogPayload(abi.encodeWithSignature("log(string,string,uint256,string)", p0, p1, p2, p3)); |
| 863 | } |
| 864 | |
| 865 | function log(string memory p0, string memory p1, uint256 p2, bool p3) internal pure { |
| 866 | _sendLogPayload(abi.encodeWithSignature("log(string,string,uint256,bool)", p0, p1, p2, p3)); |
| 867 | } |
| 868 | |
| 869 | function log(string memory p0, string memory p1, uint256 p2, address p3) internal pure { |
| 870 | _sendLogPayload(abi.encodeWithSignature("log(string,string,uint256,address)", p0, p1, p2, p3)); |
| 871 | } |
| 872 | |
| 873 | function log(string memory p0, string memory p1, string memory p2, uint256 p3) internal pure { |
| 874 | _sendLogPayload(abi.encodeWithSignature("log(string,string,string,uint256)", p0, p1, p2, p3)); |
| 875 | } |
| 876 | |
| 877 | function log(string memory p0, string memory p1, string memory p2, string memory p3) internal pure { |
| 878 | _sendLogPayload(abi.encodeWithSignature("log(string,string,string,string)", p0, p1, p2, p3)); |
| 879 | } |
| 880 | |
| 881 | function log(string memory p0, string memory p1, string memory p2, bool p3) internal pure { |
| 882 | _sendLogPayload(abi.encodeWithSignature("log(string,string,string,bool)", p0, p1, p2, p3)); |
| 883 | } |
| 884 | |
| 885 | function log(string memory p0, string memory p1, string memory p2, address p3) internal pure { |
| 886 | _sendLogPayload(abi.encodeWithSignature("log(string,string,string,address)", p0, p1, p2, p3)); |
| 887 | } |
| 888 | |
| 889 | function log(string memory p0, string memory p1, bool p2, uint256 p3) internal pure { |
| 890 | _sendLogPayload(abi.encodeWithSignature("log(string,string,bool,uint256)", p0, p1, p2, p3)); |
| 891 | } |
| 892 | |
| 893 | function log(string memory p0, string memory p1, bool p2, string memory p3) internal pure { |
| 894 | _sendLogPayload(abi.encodeWithSignature("log(string,string,bool,string)", p0, p1, p2, p3)); |
| 895 | } |
| 896 | |
| 897 | function log(string memory p0, string memory p1, bool p2, bool p3) internal pure { |
| 898 | _sendLogPayload(abi.encodeWithSignature("log(string,string,bool,bool)", p0, p1, p2, p3)); |
| 899 | } |
| 900 | |
| 901 | function log(string memory p0, string memory p1, bool p2, address p3) internal pure { |
| 902 | _sendLogPayload(abi.encodeWithSignature("log(string,string,bool,address)", p0, p1, p2, p3)); |
| 903 | } |
| 904 | |
| 905 | function log(string memory p0, string memory p1, address p2, uint256 p3) internal pure { |
| 906 | _sendLogPayload(abi.encodeWithSignature("log(string,string,address,uint256)", p0, p1, p2, p3)); |
| 907 | } |
| 908 | |
| 909 | function log(string memory p0, string memory p1, address p2, string memory p3) internal pure { |
| 910 | _sendLogPayload(abi.encodeWithSignature("log(string,string,address,string)", p0, p1, p2, p3)); |
| 911 | } |
| 912 | |
| 913 | function log(string memory p0, string memory p1, address p2, bool p3) internal pure { |
| 914 | _sendLogPayload(abi.encodeWithSignature("log(string,string,address,bool)", p0, p1, p2, p3)); |
| 915 | } |
| 916 | |
| 917 | function log(string memory p0, string memory p1, address p2, address p3) internal pure { |
| 918 | _sendLogPayload(abi.encodeWithSignature("log(string,string,address,address)", p0, p1, p2, p3)); |
| 919 | } |
| 920 | |
| 921 | function log(string memory p0, bool p1, uint256 p2, uint256 p3) internal pure { |
| 922 | _sendLogPayload(abi.encodeWithSignature("log(string,bool,uint256,uint256)", p0, p1, p2, p3)); |
| 923 | } |
| 924 | |
| 925 | function log(string memory p0, bool p1, uint256 p2, string memory p3) internal pure { |
| 926 | _sendLogPayload(abi.encodeWithSignature("log(string,bool,uint256,string)", p0, p1, p2, p3)); |
| 927 | } |
| 928 | |
| 929 | function log(string memory p0, bool p1, uint256 p2, bool p3) internal pure { |
| 930 | _sendLogPayload(abi.encodeWithSignature("log(string,bool,uint256,bool)", p0, p1, p2, p3)); |
| 931 | } |
| 932 | |
| 933 | function log(string memory p0, bool p1, uint256 p2, address p3) internal pure { |
| 934 | _sendLogPayload(abi.encodeWithSignature("log(string,bool,uint256,address)", p0, p1, p2, p3)); |
| 935 | } |
| 936 | |
| 937 | function log(string memory p0, bool p1, string memory p2, uint256 p3) internal pure { |
| 938 | _sendLogPayload(abi.encodeWithSignature("log(string,bool,string,uint256)", p0, p1, p2, p3)); |
| 939 | } |
| 940 | |
| 941 | function log(string memory p0, bool p1, string memory p2, string memory p3) internal pure { |
| 942 | _sendLogPayload(abi.encodeWithSignature("log(string,bool,string,string)", p0, p1, p2, p3)); |
| 943 | } |
| 944 | |
| 945 | function log(string memory p0, bool p1, string memory p2, bool p3) internal pure { |
| 946 | _sendLogPayload(abi.encodeWithSignature("log(string,bool,string,bool)", p0, p1, p2, p3)); |
| 947 | } |
| 948 | |
| 949 | function log(string memory p0, bool p1, string memory p2, address p3) internal pure { |
| 950 | _sendLogPayload(abi.encodeWithSignature("log(string,bool,string,address)", p0, p1, p2, p3)); |
| 951 | } |
| 952 | |
| 953 | function log(string memory p0, bool p1, bool p2, uint256 p3) internal pure { |
| 954 | _sendLogPayload(abi.encodeWithSignature("log(string,bool,bool,uint256)", p0, p1, p2, p3)); |
| 955 | } |
| 956 | |
| 957 | function log(string memory p0, bool p1, bool p2, string memory p3) internal pure { |
| 958 | _sendLogPayload(abi.encodeWithSignature("log(string,bool,bool,string)", p0, p1, p2, p3)); |
| 959 | } |
| 960 | |
| 961 | function log(string memory p0, bool p1, bool p2, bool p3) internal pure { |
| 962 | _sendLogPayload(abi.encodeWithSignature("log(string,bool,bool,bool)", p0, p1, p2, p3)); |
| 963 | } |
| 964 | |
| 965 | function log(string memory p0, bool p1, bool p2, address p3) internal pure { |
| 966 | _sendLogPayload(abi.encodeWithSignature("log(string,bool,bool,address)", p0, p1, p2, p3)); |
| 967 | } |
| 968 | |
| 969 | function log(string memory p0, bool p1, address p2, uint256 p3) internal pure { |
| 970 | _sendLogPayload(abi.encodeWithSignature("log(string,bool,address,uint256)", p0, p1, p2, p3)); |
| 971 | } |
| 972 | |
| 973 | function log(string memory p0, bool p1, address p2, string memory p3) internal pure { |
| 974 | _sendLogPayload(abi.encodeWithSignature("log(string,bool,address,string)", p0, p1, p2, p3)); |
| 975 | } |
| 976 | |
| 977 | function log(string memory p0, bool p1, address p2, bool p3) internal pure { |
| 978 | _sendLogPayload(abi.encodeWithSignature("log(string,bool,address,bool)", p0, p1, p2, p3)); |
| 979 | } |
| 980 | |
| 981 | function log(string memory p0, bool p1, address p2, address p3) internal pure { |
| 982 | _sendLogPayload(abi.encodeWithSignature("log(string,bool,address,address)", p0, p1, p2, p3)); |
| 983 | } |
| 984 | |
| 985 | function log(string memory p0, address p1, uint256 p2, uint256 p3) internal pure { |
| 986 | _sendLogPayload(abi.encodeWithSignature("log(string,address,uint256,uint256)", p0, p1, p2, p3)); |
| 987 | } |
| 988 | |
| 989 | function log(string memory p0, address p1, uint256 p2, string memory p3) internal pure { |
| 990 | _sendLogPayload(abi.encodeWithSignature("log(string,address,uint256,string)", p0, p1, p2, p3)); |
| 991 | } |
| 992 | |
| 993 | function log(string memory p0, address p1, uint256 p2, bool p3) internal pure { |
| 994 | _sendLogPayload(abi.encodeWithSignature("log(string,address,uint256,bool)", p0, p1, p2, p3)); |
| 995 | } |
| 996 | |
| 997 | function log(string memory p0, address p1, uint256 p2, address p3) internal pure { |
| 998 | _sendLogPayload(abi.encodeWithSignature("log(string,address,uint256,address)", p0, p1, p2, p3)); |
| 999 | } |
| 1000 | |
| 1001 | function log(string memory p0, address p1, string memory p2, uint256 p3) internal pure { |
| 1002 | _sendLogPayload(abi.encodeWithSignature("log(string,address,string,uint256)", p0, p1, p2, p3)); |
| 1003 | } |
| 1004 | |
| 1005 | function log(string memory p0, address p1, string memory p2, string memory p3) internal pure { |
| 1006 | _sendLogPayload(abi.encodeWithSignature("log(string,address,string,string)", p0, p1, p2, p3)); |
| 1007 | } |
| 1008 | |
| 1009 | function log(string memory p0, address p1, string memory p2, bool p3) internal pure { |
| 1010 | _sendLogPayload(abi.encodeWithSignature("log(string,address,string,bool)", p0, p1, p2, p3)); |
| 1011 | } |
| 1012 | |
| 1013 | function log(string memory p0, address p1, string memory p2, address p3) internal pure { |
| 1014 | _sendLogPayload(abi.encodeWithSignature("log(string,address,string,address)", p0, p1, p2, p3)); |
| 1015 | } |
| 1016 | |
| 1017 | function log(string memory p0, address p1, bool p2, uint256 p3) internal pure { |
| 1018 | _sendLogPayload(abi.encodeWithSignature("log(string,address,bool,uint256)", p0, p1, p2, p3)); |
| 1019 | } |
| 1020 | |
| 1021 | function log(string memory p0, address p1, bool p2, string memory p3) internal pure { |
| 1022 | _sendLogPayload(abi.encodeWithSignature("log(string,address,bool,string)", p0, p1, p2, p3)); |
| 1023 | } |
| 1024 | |
| 1025 | function log(string memory p0, address p1, bool p2, bool p3) internal pure { |
| 1026 | _sendLogPayload(abi.encodeWithSignature("log(string,address,bool,bool)", p0, p1, p2, p3)); |
| 1027 | } |
| 1028 | |
| 1029 | function log(string memory p0, address p1, bool p2, address p3) internal pure { |
| 1030 | _sendLogPayload(abi.encodeWithSignature("log(string,address,bool,address)", p0, p1, p2, p3)); |
| 1031 | } |
| 1032 | |
| 1033 | function log(string memory p0, address p1, address p2, uint256 p3) internal pure { |
| 1034 | _sendLogPayload(abi.encodeWithSignature("log(string,address,address,uint256)", p0, p1, p2, p3)); |
| 1035 | } |
| 1036 | |
| 1037 | function log(string memory p0, address p1, address p2, string memory p3) internal pure { |
| 1038 | _sendLogPayload(abi.encodeWithSignature("log(string,address,address,string)", p0, p1, p2, p3)); |
| 1039 | } |
| 1040 | |
| 1041 | function log(string memory p0, address p1, address p2, bool p3) internal pure { |
| 1042 | _sendLogPayload(abi.encodeWithSignature("log(string,address,address,bool)", p0, p1, p2, p3)); |
| 1043 | } |
| 1044 | |
| 1045 | function log(string memory p0, address p1, address p2, address p3) internal pure { |
| 1046 | _sendLogPayload(abi.encodeWithSignature("log(string,address,address,address)", p0, p1, p2, p3)); |
| 1047 | } |
| 1048 | |
| 1049 | function log(bool p0, uint256 p1, uint256 p2, uint256 p3) internal pure { |
| 1050 | _sendLogPayload(abi.encodeWithSignature("log(bool,uint256,uint256,uint256)", p0, p1, p2, p3)); |
| 1051 | } |
| 1052 | |
| 1053 | function log(bool p0, uint256 p1, uint256 p2, string memory p3) internal pure { |
| 1054 | _sendLogPayload(abi.encodeWithSignature("log(bool,uint256,uint256,string)", p0, p1, p2, p3)); |
| 1055 | } |
| 1056 | |
| 1057 | function log(bool p0, uint256 p1, uint256 p2, bool p3) internal pure { |
| 1058 | _sendLogPayload(abi.encodeWithSignature("log(bool,uint256,uint256,bool)", p0, p1, p2, p3)); |
| 1059 | } |
| 1060 | |
| 1061 | function log(bool p0, uint256 p1, uint256 p2, address p3) internal pure { |
| 1062 | _sendLogPayload(abi.encodeWithSignature("log(bool,uint256,uint256,address)", p0, p1, p2, p3)); |
| 1063 | } |
| 1064 | |
| 1065 | function log(bool p0, uint256 p1, string memory p2, uint256 p3) internal pure { |
| 1066 | _sendLogPayload(abi.encodeWithSignature("log(bool,uint256,string,uint256)", p0, p1, p2, p3)); |
| 1067 | } |
| 1068 | |
| 1069 | function log(bool p0, uint256 p1, string memory p2, string memory p3) internal pure { |
| 1070 | _sendLogPayload(abi.encodeWithSignature("log(bool,uint256,string,string)", p0, p1, p2, p3)); |
| 1071 | } |
| 1072 | |
| 1073 | function log(bool p0, uint256 p1, string memory p2, bool p3) internal pure { |
| 1074 | _sendLogPayload(abi.encodeWithSignature("log(bool,uint256,string,bool)", p0, p1, p2, p3)); |
| 1075 | } |
| 1076 | |
| 1077 | function log(bool p0, uint256 p1, string memory p2, address p3) internal pure { |
| 1078 | _sendLogPayload(abi.encodeWithSignature("log(bool,uint256,string,address)", p0, p1, p2, p3)); |
| 1079 | } |
| 1080 | |
| 1081 | function log(bool p0, uint256 p1, bool p2, uint256 p3) internal pure { |
| 1082 | _sendLogPayload(abi.encodeWithSignature("log(bool,uint256,bool,uint256)", p0, p1, p2, p3)); |
| 1083 | } |
| 1084 | |
| 1085 | function log(bool p0, uint256 p1, bool p2, string memory p3) internal pure { |
| 1086 | _sendLogPayload(abi.encodeWithSignature("log(bool,uint256,bool,string)", p0, p1, p2, p3)); |
| 1087 | } |
| 1088 | |
| 1089 | function log(bool p0, uint256 p1, bool p2, bool p3) internal pure { |
| 1090 | _sendLogPayload(abi.encodeWithSignature("log(bool,uint256,bool,bool)", p0, p1, p2, p3)); |
| 1091 | } |
| 1092 | |
| 1093 | function log(bool p0, uint256 p1, bool p2, address p3) internal pure { |
| 1094 | _sendLogPayload(abi.encodeWithSignature("log(bool,uint256,bool,address)", p0, p1, p2, p3)); |
| 1095 | } |
| 1096 | |
| 1097 | function log(bool p0, uint256 p1, address p2, uint256 p3) internal pure { |
| 1098 | _sendLogPayload(abi.encodeWithSignature("log(bool,uint256,address,uint256)", p0, p1, p2, p3)); |
| 1099 | } |
| 1100 | |
| 1101 | function log(bool p0, uint256 p1, address p2, string memory p3) internal pure { |
| 1102 | _sendLogPayload(abi.encodeWithSignature("log(bool,uint256,address,string)", p0, p1, p2, p3)); |
| 1103 | } |
| 1104 | |
| 1105 | function log(bool p0, uint256 p1, address p2, bool p3) internal pure { |
| 1106 | _sendLogPayload(abi.encodeWithSignature("log(bool,uint256,address,bool)", p0, p1, p2, p3)); |
| 1107 | } |
| 1108 | |
| 1109 | function log(bool p0, uint256 p1, address p2, address p3) internal pure { |
| 1110 | _sendLogPayload(abi.encodeWithSignature("log(bool,uint256,address,address)", p0, p1, p2, p3)); |
| 1111 | } |
| 1112 | |
| 1113 | function log(bool p0, string memory p1, uint256 p2, uint256 p3) internal pure { |
| 1114 | _sendLogPayload(abi.encodeWithSignature("log(bool,string,uint256,uint256)", p0, p1, p2, p3)); |
| 1115 | } |
| 1116 | |
| 1117 | function log(bool p0, string memory p1, uint256 p2, string memory p3) internal pure { |
| 1118 | _sendLogPayload(abi.encodeWithSignature("log(bool,string,uint256,string)", p0, p1, p2, p3)); |
| 1119 | } |
| 1120 | |
| 1121 | function log(bool p0, string memory p1, uint256 p2, bool p3) internal pure { |
| 1122 | _sendLogPayload(abi.encodeWithSignature("log(bool,string,uint256,bool)", p0, p1, p2, p3)); |
| 1123 | } |
| 1124 | |
| 1125 | function log(bool p0, string memory p1, uint256 p2, address p3) internal pure { |
| 1126 | _sendLogPayload(abi.encodeWithSignature("log(bool,string,uint256,address)", p0, p1, p2, p3)); |
| 1127 | } |
| 1128 | |
| 1129 | function log(bool p0, string memory p1, string memory p2, uint256 p3) internal pure { |
| 1130 | _sendLogPayload(abi.encodeWithSignature("log(bool,string,string,uint256)", p0, p1, p2, p3)); |
| 1131 | } |
| 1132 | |
| 1133 | function log(bool p0, string memory p1, string memory p2, string memory p3) internal pure { |
| 1134 | _sendLogPayload(abi.encodeWithSignature("log(bool,string,string,string)", p0, p1, p2, p3)); |
| 1135 | } |
| 1136 | |
| 1137 | function log(bool p0, string memory p1, string memory p2, bool p3) internal pure { |
| 1138 | _sendLogPayload(abi.encodeWithSignature("log(bool,string,string,bool)", p0, p1, p2, p3)); |
| 1139 | } |
| 1140 | |
| 1141 | function log(bool p0, string memory p1, string memory p2, address p3) internal pure { |
| 1142 | _sendLogPayload(abi.encodeWithSignature("log(bool,string,string,address)", p0, p1, p2, p3)); |
| 1143 | } |
| 1144 | |
| 1145 | function log(bool p0, string memory p1, bool p2, uint256 p3) internal pure { |
| 1146 | _sendLogPayload(abi.encodeWithSignature("log(bool,string,bool,uint256)", p0, p1, p2, p3)); |
| 1147 | } |
| 1148 | |
| 1149 | function log(bool p0, string memory p1, bool p2, string memory p3) internal pure { |
| 1150 | _sendLogPayload(abi.encodeWithSignature("log(bool,string,bool,string)", p0, p1, p2, p3)); |
| 1151 | } |
| 1152 | |
| 1153 | function log(bool p0, string memory p1, bool p2, bool p3) internal pure { |
| 1154 | _sendLogPayload(abi.encodeWithSignature("log(bool,string,bool,bool)", p0, p1, p2, p3)); |
| 1155 | } |
| 1156 | |
| 1157 | function log(bool p0, string memory p1, bool p2, address p3) internal pure { |
| 1158 | _sendLogPayload(abi.encodeWithSignature("log(bool,string,bool,address)", p0, p1, p2, p3)); |
| 1159 | } |
| 1160 | |
| 1161 | function log(bool p0, string memory p1, address p2, uint256 p3) internal pure { |
| 1162 | _sendLogPayload(abi.encodeWithSignature("log(bool,string,address,uint256)", p0, p1, p2, p3)); |
| 1163 | } |
| 1164 | |
| 1165 | function log(bool p0, string memory p1, address p2, string memory p3) internal pure { |
| 1166 | _sendLogPayload(abi.encodeWithSignature("log(bool,string,address,string)", p0, p1, p2, p3)); |
| 1167 | } |
| 1168 | |
| 1169 | function log(bool p0, string memory p1, address p2, bool p3) internal pure { |
| 1170 | _sendLogPayload(abi.encodeWithSignature("log(bool,string,address,bool)", p0, p1, p2, p3)); |
| 1171 | } |
| 1172 | |
| 1173 | function log(bool p0, string memory p1, address p2, address p3) internal pure { |
| 1174 | _sendLogPayload(abi.encodeWithSignature("log(bool,string,address,address)", p0, p1, p2, p3)); |
| 1175 | } |
| 1176 | |
| 1177 | function log(bool p0, bool p1, uint256 p2, uint256 p3) internal pure { |
| 1178 | _sendLogPayload(abi.encodeWithSignature("log(bool,bool,uint256,uint256)", p0, p1, p2, p3)); |
| 1179 | } |
| 1180 | |
| 1181 | function log(bool p0, bool p1, uint256 p2, string memory p3) internal pure { |
| 1182 | _sendLogPayload(abi.encodeWithSignature("log(bool,bool,uint256,string)", p0, p1, p2, p3)); |
| 1183 | } |
| 1184 | |
| 1185 | function log(bool p0, bool p1, uint256 p2, bool p3) internal pure { |
| 1186 | _sendLogPayload(abi.encodeWithSignature("log(bool,bool,uint256,bool)", p0, p1, p2, p3)); |
| 1187 | } |
| 1188 | |
| 1189 | function log(bool p0, bool p1, uint256 p2, address p3) internal pure { |
| 1190 | _sendLogPayload(abi.encodeWithSignature("log(bool,bool,uint256,address)", p0, p1, p2, p3)); |
| 1191 | } |
| 1192 | |
| 1193 | function log(bool p0, bool p1, string memory p2, uint256 p3) internal pure { |
| 1194 | _sendLogPayload(abi.encodeWithSignature("log(bool,bool,string,uint256)", p0, p1, p2, p3)); |
| 1195 | } |
| 1196 | |
| 1197 | function log(bool p0, bool p1, string memory p2, string memory p3) internal pure { |
| 1198 | _sendLogPayload(abi.encodeWithSignature("log(bool,bool,string,string)", p0, p1, p2, p3)); |
| 1199 | } |
| 1200 | |
| 1201 | function log(bool p0, bool p1, string memory p2, bool p3) internal pure { |
| 1202 | _sendLogPayload(abi.encodeWithSignature("log(bool,bool,string,bool)", p0, p1, p2, p3)); |
| 1203 | } |
| 1204 | |
| 1205 | function log(bool p0, bool p1, string memory p2, address p3) internal pure { |
| 1206 | _sendLogPayload(abi.encodeWithSignature("log(bool,bool,string,address)", p0, p1, p2, p3)); |
| 1207 | } |
| 1208 | |
| 1209 | function log(bool p0, bool p1, bool p2, uint256 p3) internal pure { |
| 1210 | _sendLogPayload(abi.encodeWithSignature("log(bool,bool,bool,uint256)", p0, p1, p2, p3)); |
| 1211 | } |
| 1212 | |
| 1213 | function log(bool p0, bool p1, bool p2, string memory p3) internal pure { |
| 1214 | _sendLogPayload(abi.encodeWithSignature("log(bool,bool,bool,string)", p0, p1, p2, p3)); |
| 1215 | } |
| 1216 | |
| 1217 | function log(bool p0, bool p1, bool p2, bool p3) internal pure { |
| 1218 | _sendLogPayload(abi.encodeWithSignature("log(bool,bool,bool,bool)", p0, p1, p2, p3)); |
| 1219 | } |
| 1220 | |
| 1221 | function log(bool p0, bool p1, bool p2, address p3) internal pure { |
| 1222 | _sendLogPayload(abi.encodeWithSignature("log(bool,bool,bool,address)", p0, p1, p2, p3)); |
| 1223 | } |
| 1224 | |
| 1225 | function log(bool p0, bool p1, address p2, uint256 p3) internal pure { |
| 1226 | _sendLogPayload(abi.encodeWithSignature("log(bool,bool,address,uint256)", p0, p1, p2, p3)); |
| 1227 | } |
| 1228 | |
| 1229 | function log(bool p0, bool p1, address p2, string memory p3) internal pure { |
| 1230 | _sendLogPayload(abi.encodeWithSignature("log(bool,bool,address,string)", p0, p1, p2, p3)); |
| 1231 | } |
| 1232 | |
| 1233 | function log(bool p0, bool p1, address p2, bool p3) internal pure { |
| 1234 | _sendLogPayload(abi.encodeWithSignature("log(bool,bool,address,bool)", p0, p1, p2, p3)); |
| 1235 | } |
| 1236 | |
| 1237 | function log(bool p0, bool p1, address p2, address p3) internal pure { |
| 1238 | _sendLogPayload(abi.encodeWithSignature("log(bool,bool,address,address)", p0, p1, p2, p3)); |
| 1239 | } |
| 1240 | |
| 1241 | function log(bool p0, address p1, uint256 p2, uint256 p3) internal pure { |
| 1242 | _sendLogPayload(abi.encodeWithSignature("log(bool,address,uint256,uint256)", p0, p1, p2, p3)); |
| 1243 | } |
| 1244 | |
| 1245 | function log(bool p0, address p1, uint256 p2, string memory p3) internal pure { |
| 1246 | _sendLogPayload(abi.encodeWithSignature("log(bool,address,uint256,string)", p0, p1, p2, p3)); |
| 1247 | } |
| 1248 | |
| 1249 | function log(bool p0, address p1, uint256 p2, bool p3) internal pure { |
| 1250 | _sendLogPayload(abi.encodeWithSignature("log(bool,address,uint256,bool)", p0, p1, p2, p3)); |
| 1251 | } |
| 1252 | |
| 1253 | function log(bool p0, address p1, uint256 p2, address p3) internal pure { |
| 1254 | _sendLogPayload(abi.encodeWithSignature("log(bool,address,uint256,address)", p0, p1, p2, p3)); |
| 1255 | } |
| 1256 | |
| 1257 | function log(bool p0, address p1, string memory p2, uint256 p3) internal pure { |
| 1258 | _sendLogPayload(abi.encodeWithSignature("log(bool,address,string,uint256)", p0, p1, p2, p3)); |
| 1259 | } |
| 1260 | |
| 1261 | function log(bool p0, address p1, string memory p2, string memory p3) internal pure { |
| 1262 | _sendLogPayload(abi.encodeWithSignature("log(bool,address,string,string)", p0, p1, p2, p3)); |
| 1263 | } |
| 1264 | |
| 1265 | function log(bool p0, address p1, string memory p2, bool p3) internal pure { |
| 1266 | _sendLogPayload(abi.encodeWithSignature("log(bool,address,string,bool)", p0, p1, p2, p3)); |
| 1267 | } |
| 1268 | |
| 1269 | function log(bool p0, address p1, string memory p2, address p3) internal pure { |
| 1270 | _sendLogPayload(abi.encodeWithSignature("log(bool,address,string,address)", p0, p1, p2, p3)); |
| 1271 | } |
| 1272 | |
| 1273 | function log(bool p0, address p1, bool p2, uint256 p3) internal pure { |
| 1274 | _sendLogPayload(abi.encodeWithSignature("log(bool,address,bool,uint256)", p0, p1, p2, p3)); |
| 1275 | } |
| 1276 | |
| 1277 | function log(bool p0, address p1, bool p2, string memory p3) internal pure { |
| 1278 | _sendLogPayload(abi.encodeWithSignature("log(bool,address,bool,string)", p0, p1, p2, p3)); |
| 1279 | } |
| 1280 | |
| 1281 | function log(bool p0, address p1, bool p2, bool p3) internal pure { |
| 1282 | _sendLogPayload(abi.encodeWithSignature("log(bool,address,bool,bool)", p0, p1, p2, p3)); |
| 1283 | } |
| 1284 | |
| 1285 | function log(bool p0, address p1, bool p2, address p3) internal pure { |
| 1286 | _sendLogPayload(abi.encodeWithSignature("log(bool,address,bool,address)", p0, p1, p2, p3)); |
| 1287 | } |
| 1288 | |
| 1289 | function log(bool p0, address p1, address p2, uint256 p3) internal pure { |
| 1290 | _sendLogPayload(abi.encodeWithSignature("log(bool,address,address,uint256)", p0, p1, p2, p3)); |
| 1291 | } |
| 1292 | |
| 1293 | function log(bool p0, address p1, address p2, string memory p3) internal pure { |
| 1294 | _sendLogPayload(abi.encodeWithSignature("log(bool,address,address,string)", p0, p1, p2, p3)); |
| 1295 | } |
| 1296 | |
| 1297 | function log(bool p0, address p1, address p2, bool p3) internal pure { |
| 1298 | _sendLogPayload(abi.encodeWithSignature("log(bool,address,address,bool)", p0, p1, p2, p3)); |
| 1299 | } |
| 1300 | |
| 1301 | function log(bool p0, address p1, address p2, address p3) internal pure { |
| 1302 | _sendLogPayload(abi.encodeWithSignature("log(bool,address,address,address)", p0, p1, p2, p3)); |
| 1303 | } |
| 1304 | |
| 1305 | function log(address p0, uint256 p1, uint256 p2, uint256 p3) internal pure { |
| 1306 | _sendLogPayload(abi.encodeWithSignature("log(address,uint256,uint256,uint256)", p0, p1, p2, p3)); |
| 1307 | } |
| 1308 | |
| 1309 | function log(address p0, uint256 p1, uint256 p2, string memory p3) internal pure { |
| 1310 | _sendLogPayload(abi.encodeWithSignature("log(address,uint256,uint256,string)", p0, p1, p2, p3)); |
| 1311 | } |
| 1312 | |
| 1313 | function log(address p0, uint256 p1, uint256 p2, bool p3) internal pure { |
| 1314 | _sendLogPayload(abi.encodeWithSignature("log(address,uint256,uint256,bool)", p0, p1, p2, p3)); |
| 1315 | } |
| 1316 | |
| 1317 | function log(address p0, uint256 p1, uint256 p2, address p3) internal pure { |
| 1318 | _sendLogPayload(abi.encodeWithSignature("log(address,uint256,uint256,address)", p0, p1, p2, p3)); |
| 1319 | } |
| 1320 | |
| 1321 | function log(address p0, uint256 p1, string memory p2, uint256 p3) internal pure { |
| 1322 | _sendLogPayload(abi.encodeWithSignature("log(address,uint256,string,uint256)", p0, p1, p2, p3)); |
| 1323 | } |
| 1324 | |
| 1325 | function log(address p0, uint256 p1, string memory p2, string memory p3) internal pure { |
| 1326 | _sendLogPayload(abi.encodeWithSignature("log(address,uint256,string,string)", p0, p1, p2, p3)); |
| 1327 | } |
| 1328 | |
| 1329 | function log(address p0, uint256 p1, string memory p2, bool p3) internal pure { |
| 1330 | _sendLogPayload(abi.encodeWithSignature("log(address,uint256,string,bool)", p0, p1, p2, p3)); |
| 1331 | } |
| 1332 | |
| 1333 | function log(address p0, uint256 p1, string memory p2, address p3) internal pure { |
| 1334 | _sendLogPayload(abi.encodeWithSignature("log(address,uint256,string,address)", p0, p1, p2, p3)); |
| 1335 | } |
| 1336 | |
| 1337 | function log(address p0, uint256 p1, bool p2, uint256 p3) internal pure { |
| 1338 | _sendLogPayload(abi.encodeWithSignature("log(address,uint256,bool,uint256)", p0, p1, p2, p3)); |
| 1339 | } |
| 1340 | |
| 1341 | function log(address p0, uint256 p1, bool p2, string memory p3) internal pure { |
| 1342 | _sendLogPayload(abi.encodeWithSignature("log(address,uint256,bool,string)", p0, p1, p2, p3)); |
| 1343 | } |
| 1344 | |
| 1345 | function log(address p0, uint256 p1, bool p2, bool p3) internal pure { |
| 1346 | _sendLogPayload(abi.encodeWithSignature("log(address,uint256,bool,bool)", p0, p1, p2, p3)); |
| 1347 | } |
| 1348 | |
| 1349 | function log(address p0, uint256 p1, bool p2, address p3) internal pure { |
| 1350 | _sendLogPayload(abi.encodeWithSignature("log(address,uint256,bool,address)", p0, p1, p2, p3)); |
| 1351 | } |
| 1352 | |
| 1353 | function log(address p0, uint256 p1, address p2, uint256 p3) internal pure { |
| 1354 | _sendLogPayload(abi.encodeWithSignature("log(address,uint256,address,uint256)", p0, p1, p2, p3)); |
| 1355 | } |
| 1356 | |
| 1357 | function log(address p0, uint256 p1, address p2, string memory p3) internal pure { |
| 1358 | _sendLogPayload(abi.encodeWithSignature("log(address,uint256,address,string)", p0, p1, p2, p3)); |
| 1359 | } |
| 1360 | |
| 1361 | function log(address p0, uint256 p1, address p2, bool p3) internal pure { |
| 1362 | _sendLogPayload(abi.encodeWithSignature("log(address,uint256,address,bool)", p0, p1, p2, p3)); |
| 1363 | } |
| 1364 | |
| 1365 | function log(address p0, uint256 p1, address p2, address p3) internal pure { |
| 1366 | _sendLogPayload(abi.encodeWithSignature("log(address,uint256,address,address)", p0, p1, p2, p3)); |
| 1367 | } |
| 1368 | |
| 1369 | function log(address p0, string memory p1, uint256 p2, uint256 p3) internal pure { |
| 1370 | _sendLogPayload(abi.encodeWithSignature("log(address,string,uint256,uint256)", p0, p1, p2, p3)); |
| 1371 | } |
| 1372 | |
| 1373 | function log(address p0, string memory p1, uint256 p2, string memory p3) internal pure { |
| 1374 | _sendLogPayload(abi.encodeWithSignature("log(address,string,uint256,string)", p0, p1, p2, p3)); |
| 1375 | } |
| 1376 | |
| 1377 | function log(address p0, string memory p1, uint256 p2, bool p3) internal pure { |
| 1378 | _sendLogPayload(abi.encodeWithSignature("log(address,string,uint256,bool)", p0, p1, p2, p3)); |
| 1379 | } |
| 1380 | |
| 1381 | function log(address p0, string memory p1, uint256 p2, address p3) internal pure { |
| 1382 | _sendLogPayload(abi.encodeWithSignature("log(address,string,uint256,address)", p0, p1, p2, p3)); |
| 1383 | } |
| 1384 | |
| 1385 | function log(address p0, string memory p1, string memory p2, uint256 p3) internal pure { |
| 1386 | _sendLogPayload(abi.encodeWithSignature("log(address,string,string,uint256)", p0, p1, p2, p3)); |
| 1387 | } |
| 1388 | |
| 1389 | function log(address p0, string memory p1, string memory p2, string memory p3) internal pure { |
| 1390 | _sendLogPayload(abi.encodeWithSignature("log(address,string,string,string)", p0, p1, p2, p3)); |
| 1391 | } |
| 1392 | |
| 1393 | function log(address p0, string memory p1, string memory p2, bool p3) internal pure { |
| 1394 | _sendLogPayload(abi.encodeWithSignature("log(address,string,string,bool)", p0, p1, p2, p3)); |
| 1395 | } |
| 1396 | |
| 1397 | function log(address p0, string memory p1, string memory p2, address p3) internal pure { |
| 1398 | _sendLogPayload(abi.encodeWithSignature("log(address,string,string,address)", p0, p1, p2, p3)); |
| 1399 | } |
| 1400 | |
| 1401 | function log(address p0, string memory p1, bool p2, uint256 p3) internal pure { |
| 1402 | _sendLogPayload(abi.encodeWithSignature("log(address,string,bool,uint256)", p0, p1, p2, p3)); |
| 1403 | } |
| 1404 | |
| 1405 | function log(address p0, string memory p1, bool p2, string memory p3) internal pure { |
| 1406 | _sendLogPayload(abi.encodeWithSignature("log(address,string,bool,string)", p0, p1, p2, p3)); |
| 1407 | } |
| 1408 | |
| 1409 | function log(address p0, string memory p1, bool p2, bool p3) internal pure { |
| 1410 | _sendLogPayload(abi.encodeWithSignature("log(address,string,bool,bool)", p0, p1, p2, p3)); |
| 1411 | } |
| 1412 | |
| 1413 | function log(address p0, string memory p1, bool p2, address p3) internal pure { |
| 1414 | _sendLogPayload(abi.encodeWithSignature("log(address,string,bool,address)", p0, p1, p2, p3)); |
| 1415 | } |
| 1416 | |
| 1417 | function log(address p0, string memory p1, address p2, uint256 p3) internal pure { |
| 1418 | _sendLogPayload(abi.encodeWithSignature("log(address,string,address,uint256)", p0, p1, p2, p3)); |
| 1419 | } |
| 1420 | |
| 1421 | function log(address p0, string memory p1, address p2, string memory p3) internal pure { |
| 1422 | _sendLogPayload(abi.encodeWithSignature("log(address,string,address,string)", p0, p1, p2, p3)); |
| 1423 | } |
| 1424 | |
| 1425 | function log(address p0, string memory p1, address p2, bool p3) internal pure { |
| 1426 | _sendLogPayload(abi.encodeWithSignature("log(address,string,address,bool)", p0, p1, p2, p3)); |
| 1427 | } |
| 1428 | |
| 1429 | function log(address p0, string memory p1, address p2, address p3) internal pure { |
| 1430 | _sendLogPayload(abi.encodeWithSignature("log(address,string,address,address)", p0, p1, p2, p3)); |
| 1431 | } |
| 1432 | |
| 1433 | function log(address p0, bool p1, uint256 p2, uint256 p3) internal pure { |
| 1434 | _sendLogPayload(abi.encodeWithSignature("log(address,bool,uint256,uint256)", p0, p1, p2, p3)); |
| 1435 | } |
| 1436 | |
| 1437 | function log(address p0, bool p1, uint256 p2, string memory p3) internal pure { |
| 1438 | _sendLogPayload(abi.encodeWithSignature("log(address,bool,uint256,string)", p0, p1, p2, p3)); |
| 1439 | } |
| 1440 | |
| 1441 | function log(address p0, bool p1, uint256 p2, bool p3) internal pure { |
| 1442 | _sendLogPayload(abi.encodeWithSignature("log(address,bool,uint256,bool)", p0, p1, p2, p3)); |
| 1443 | } |
| 1444 | |
| 1445 | function log(address p0, bool p1, uint256 p2, address p3) internal pure { |
| 1446 | _sendLogPayload(abi.encodeWithSignature("log(address,bool,uint256,address)", p0, p1, p2, p3)); |
| 1447 | } |
| 1448 | |
| 1449 | function log(address p0, bool p1, string memory p2, uint256 p3) internal pure { |
| 1450 | _sendLogPayload(abi.encodeWithSignature("log(address,bool,string,uint256)", p0, p1, p2, p3)); |
| 1451 | } |
| 1452 | |
| 1453 | function log(address p0, bool p1, string memory p2, string memory p3) internal pure { |
| 1454 | _sendLogPayload(abi.encodeWithSignature("log(address,bool,string,string)", p0, p1, p2, p3)); |
| 1455 | } |
| 1456 | |
| 1457 | function log(address p0, bool p1, string memory p2, bool p3) internal pure { |
| 1458 | _sendLogPayload(abi.encodeWithSignature("log(address,bool,string,bool)", p0, p1, p2, p3)); |
| 1459 | } |
| 1460 | |
| 1461 | function log(address p0, bool p1, string memory p2, address p3) internal pure { |
| 1462 | _sendLogPayload(abi.encodeWithSignature("log(address,bool,string,address)", p0, p1, p2, p3)); |
| 1463 | } |
| 1464 | |
| 1465 | function log(address p0, bool p1, bool p2, uint256 p3) internal pure { |
| 1466 | _sendLogPayload(abi.encodeWithSignature("log(address,bool,bool,uint256)", p0, p1, p2, p3)); |
| 1467 | } |
| 1468 | |
| 1469 | function log(address p0, bool p1, bool p2, string memory p3) internal pure { |
| 1470 | _sendLogPayload(abi.encodeWithSignature("log(address,bool,bool,string)", p0, p1, p2, p3)); |
| 1471 | } |
| 1472 | |
| 1473 | function log(address p0, bool p1, bool p2, bool p3) internal pure { |
| 1474 | _sendLogPayload(abi.encodeWithSignature("log(address,bool,bool,bool)", p0, p1, p2, p3)); |
| 1475 | } |
| 1476 | |
| 1477 | function log(address p0, bool p1, bool p2, address p3) internal pure { |
| 1478 | _sendLogPayload(abi.encodeWithSignature("log(address,bool,bool,address)", p0, p1, p2, p3)); |
| 1479 | } |
| 1480 | |
| 1481 | function log(address p0, bool p1, address p2, uint256 p3) internal pure { |
| 1482 | _sendLogPayload(abi.encodeWithSignature("log(address,bool,address,uint256)", p0, p1, p2, p3)); |
| 1483 | } |
| 1484 | |
| 1485 | function log(address p0, bool p1, address p2, string memory p3) internal pure { |
| 1486 | _sendLogPayload(abi.encodeWithSignature("log(address,bool,address,string)", p0, p1, p2, p3)); |
| 1487 | } |
| 1488 | |
| 1489 | function log(address p0, bool p1, address p2, bool p3) internal pure { |
| 1490 | _sendLogPayload(abi.encodeWithSignature("log(address,bool,address,bool)", p0, p1, p2, p3)); |
| 1491 | } |
| 1492 | |
| 1493 | function log(address p0, bool p1, address p2, address p3) internal pure { |
| 1494 | _sendLogPayload(abi.encodeWithSignature("log(address,bool,address,address)", p0, p1, p2, p3)); |
| 1495 | } |
| 1496 | |
| 1497 | function log(address p0, address p1, uint256 p2, uint256 p3) internal pure { |
| 1498 | _sendLogPayload(abi.encodeWithSignature("log(address,address,uint256,uint256)", p0, p1, p2, p3)); |
| 1499 | } |
| 1500 | |
| 1501 | function log(address p0, address p1, uint256 p2, string memory p3) internal pure { |
| 1502 | _sendLogPayload(abi.encodeWithSignature("log(address,address,uint256,string)", p0, p1, p2, p3)); |
| 1503 | } |
| 1504 | |
| 1505 | function log(address p0, address p1, uint256 p2, bool p3) internal pure { |
| 1506 | _sendLogPayload(abi.encodeWithSignature("log(address,address,uint256,bool)", p0, p1, p2, p3)); |
| 1507 | } |
| 1508 | |
| 1509 | function log(address p0, address p1, uint256 p2, address p3) internal pure { |
| 1510 | _sendLogPayload(abi.encodeWithSignature("log(address,address,uint256,address)", p0, p1, p2, p3)); |
| 1511 | } |
| 1512 | |
| 1513 | function log(address p0, address p1, string memory p2, uint256 p3) internal pure { |
| 1514 | _sendLogPayload(abi.encodeWithSignature("log(address,address,string,uint256)", p0, p1, p2, p3)); |
| 1515 | } |
| 1516 | |
| 1517 | function log(address p0, address p1, string memory p2, string memory p3) internal pure { |
| 1518 | _sendLogPayload(abi.encodeWithSignature("log(address,address,string,string)", p0, p1, p2, p3)); |
| 1519 | } |
| 1520 | |
| 1521 | function log(address p0, address p1, string memory p2, bool p3) internal pure { |
| 1522 | _sendLogPayload(abi.encodeWithSignature("log(address,address,string,bool)", p0, p1, p2, p3)); |
| 1523 | } |
| 1524 | |
| 1525 | function log(address p0, address p1, string memory p2, address p3) internal pure { |
| 1526 | _sendLogPayload(abi.encodeWithSignature("log(address,address,string,address)", p0, p1, p2, p3)); |
| 1527 | } |
| 1528 | |
| 1529 | function log(address p0, address p1, bool p2, uint256 p3) internal pure { |
| 1530 | _sendLogPayload(abi.encodeWithSignature("log(address,address,bool,uint256)", p0, p1, p2, p3)); |
| 1531 | } |
| 1532 | |
| 1533 | function log(address p0, address p1, bool p2, string memory p3) internal pure { |
| 1534 | _sendLogPayload(abi.encodeWithSignature("log(address,address,bool,string)", p0, p1, p2, p3)); |
| 1535 | } |
| 1536 | |
| 1537 | function log(address p0, address p1, bool p2, bool p3) internal pure { |
| 1538 | _sendLogPayload(abi.encodeWithSignature("log(address,address,bool,bool)", p0, p1, p2, p3)); |
| 1539 | } |
| 1540 | |
| 1541 | function log(address p0, address p1, bool p2, address p3) internal pure { |
| 1542 | _sendLogPayload(abi.encodeWithSignature("log(address,address,bool,address)", p0, p1, p2, p3)); |
| 1543 | } |
| 1544 | |
| 1545 | function log(address p0, address p1, address p2, uint256 p3) internal pure { |
| 1546 | _sendLogPayload(abi.encodeWithSignature("log(address,address,address,uint256)", p0, p1, p2, p3)); |
| 1547 | } |
| 1548 | |
| 1549 | function log(address p0, address p1, address p2, string memory p3) internal pure { |
| 1550 | _sendLogPayload(abi.encodeWithSignature("log(address,address,address,string)", p0, p1, p2, p3)); |
| 1551 | } |
| 1552 | |
| 1553 | function log(address p0, address p1, address p2, bool p3) internal pure { |
| 1554 | _sendLogPayload(abi.encodeWithSignature("log(address,address,address,bool)", p0, p1, p2, p3)); |
| 1555 | } |
| 1556 | |
| 1557 | function log(address p0, address p1, address p2, address p3) internal pure { |
| 1558 | _sendLogPayload(abi.encodeWithSignature("log(address,address,address,address)", p0, p1, p2, p3)); |
| 1559 | } |
| 1560 | } |
| 1561 |
0.0%
lib/forge-std/src/console2.sol
Lines covered: 0 / 0 (0.0%)
| 1 | // SPDX-License-Identifier: MIT |
| 2 | pragma solidity >=0.4.22 <0.9.0; |
| 3 | |
| 4 | import {console as console2} from "./console.sol"; |
| 5 |
0.0%
lib/forge-std/src/interfaces/IMulticall3.sol
Lines covered: 0 / 0 (0.0%)
| 1 | // SPDX-License-Identifier: MIT |
| 2 | pragma solidity >=0.6.2 <0.9.0; |
| 3 | |
| 4 | pragma experimental ABIEncoderV2; |
| 5 | |
| 6 | interface IMulticall3 { |
| 7 | struct Call { |
| 8 | address target; |
| 9 | bytes callData; |
| 10 | } |
| 11 | |
| 12 | struct Call3 { |
| 13 | address target; |
| 14 | bool allowFailure; |
| 15 | bytes callData; |
| 16 | } |
| 17 | |
| 18 | struct Call3Value { |
| 19 | address target; |
| 20 | bool allowFailure; |
| 21 | uint256 value; |
| 22 | bytes callData; |
| 23 | } |
| 24 | |
| 25 | struct Result { |
| 26 | bool success; |
| 27 | bytes returnData; |
| 28 | } |
| 29 | |
| 30 | function aggregate(Call[] calldata calls) external payable returns (uint256 blockNumber, bytes[] memory returnData); |
| 31 | |
| 32 | function aggregate3(Call3[] calldata calls) external payable returns (Result[] memory returnData); |
| 33 | |
| 34 | function aggregate3Value(Call3Value[] calldata calls) external payable returns (Result[] memory returnData); |
| 35 | |
| 36 | function blockAndAggregate(Call[] calldata calls) |
| 37 | external |
| 38 | payable |
| 39 | returns (uint256 blockNumber, bytes32 blockHash, Result[] memory returnData); |
| 40 | |
| 41 | function getBasefee() external view returns (uint256 basefee); |
| 42 | |
| 43 | function getBlockHash(uint256 blockNumber) external view returns (bytes32 blockHash); |
| 44 | |
| 45 | function getBlockNumber() external view returns (uint256 blockNumber); |
| 46 | |
| 47 | function getChainId() external view returns (uint256 chainid); |
| 48 | |
| 49 | function getCurrentBlockCoinbase() external view returns (address coinbase); |
| 50 | |
| 51 | function getCurrentBlockDifficulty() external view returns (uint256 difficulty); |
| 52 | |
| 53 | function getCurrentBlockGasLimit() external view returns (uint256 gaslimit); |
| 54 | |
| 55 | function getCurrentBlockTimestamp() external view returns (uint256 timestamp); |
| 56 | |
| 57 | function getEthBalance(address addr) external view returns (uint256 balance); |
| 58 | |
| 59 | function getLastBlockHash() external view returns (bytes32 blockHash); |
| 60 | |
| 61 | function tryAggregate(bool requireSuccess, Call[] calldata calls) |
| 62 | external |
| 63 | payable |
| 64 | returns (Result[] memory returnData); |
| 65 | |
| 66 | function tryBlockAndAggregate(bool requireSuccess, Call[] calldata calls) |
| 67 | external |
| 68 | payable |
| 69 | returns (uint256 blockNumber, bytes32 blockHash, Result[] memory returnData); |
| 70 | } |
| 71 |
0.0%
lib/forge-std/src/safeconsole.sol
Lines covered: 0 / 1 (0.0%)
| 1 | // SPDX-License-Identifier: MIT |
| 2 | pragma solidity >=0.6.2 <0.9.0; |
| 3 | |
| 4 | /// @author philogy <https://github.com/philogy> |
| 5 | /// @dev Code generated automatically by script. |
| 6 | library safeconsole { |
| 7 | uint256 constant CONSOLE_ADDR = 0x000000000000000000000000000000000000000000636F6e736F6c652e6c6f67; |
| 8 | |
| 9 | // Credit to [0age](https://twitter.com/z0age/status/1654922202930888704) and [0xdapper](https://github.com/foundry-rs/forge-std/pull/374) |
| 10 | // for the view-to-pure log trick. |
| 11 | function _sendLogPayload(uint256 offset, uint256 size) private pure { |
| 12 | function(uint256, uint256) internal view fnIn = _sendLogPayloadView; |
| 13 | function(uint256, uint256) internal pure pureSendLogPayload; |
| 14 | /// @solidity memory-safe-assembly |
| 15 | assembly { |
| 16 | pureSendLogPayload := fnIn |
| 17 | } |
| 18 | pureSendLogPayload(offset, size); |
| 19 | } |
| 20 | |
| 21 | function _sendLogPayloadView(uint256 offset, uint256 size) private view { |
| 22 | /// @solidity memory-safe-assembly |
| 23 | assembly { |
| 24 | pop(staticcall(gas(), CONSOLE_ADDR, offset, size, 0x0, 0x0)) |
| 25 | } |
| 26 | } |
| 27 | |
| 28 | function _memcopy(uint256 fromOffset, uint256 toOffset, uint256 length) private pure { |
| 29 | function(uint256, uint256, uint256) internal view fnIn = _memcopyView; |
| 30 | function(uint256, uint256, uint256) internal pure pureMemcopy; |
| 31 | /// @solidity memory-safe-assembly |
| 32 | assembly { |
| 33 | pureMemcopy := fnIn |
| 34 | } |
| 35 | pureMemcopy(fromOffset, toOffset, length); |
| 36 | } |
| 37 | |
| 38 | function _memcopyView(uint256 fromOffset, uint256 toOffset, uint256 length) private view { |
| 39 | /// @solidity memory-safe-assembly |
| 40 | assembly { |
| 41 | pop(staticcall(gas(), 0x4, fromOffset, length, toOffset, length)) |
| 42 | } |
| 43 | } |
| 44 | |
| 45 | function logMemory(uint256 offset, uint256 length) internal pure { |
| 46 | if (offset >= 0x60) { |
| 47 | // Sufficient memory before slice to prepare call header. |
| 48 | bytes32 m0; |
| 49 | bytes32 m1; |
| 50 | bytes32 m2; |
| 51 | /// @solidity memory-safe-assembly |
| 52 | assembly { |
| 53 | m0 := mload(sub(offset, 0x60)) |
| 54 | m1 := mload(sub(offset, 0x40)) |
| 55 | m2 := mload(sub(offset, 0x20)) |
| 56 | // Selector of `log(bytes)`. |
| 57 | mstore(sub(offset, 0x60), 0x0be77f56) |
| 58 | mstore(sub(offset, 0x40), 0x20) |
| 59 | mstore(sub(offset, 0x20), length) |
| 60 | } |
| 61 | _sendLogPayload(offset - 0x44, length + 0x44); |
| 62 | /// @solidity memory-safe-assembly |
| 63 | assembly { |
| 64 | mstore(sub(offset, 0x60), m0) |
| 65 | mstore(sub(offset, 0x40), m1) |
| 66 | mstore(sub(offset, 0x20), m2) |
| 67 | } |
| 68 | } else { |
| 69 | // Insufficient space, so copy slice forward, add header and reverse. |
| 70 | bytes32 m0; |
| 71 | bytes32 m1; |
| 72 | bytes32 m2; |
| 73 | uint256 endOffset = offset + length; |
| 74 | /// @solidity memory-safe-assembly |
| 75 | assembly { |
| 76 | m0 := mload(add(endOffset, 0x00)) |
| 77 | m1 := mload(add(endOffset, 0x20)) |
| 78 | m2 := mload(add(endOffset, 0x40)) |
| 79 | } |
| 80 | _memcopy(offset, offset + 0x60, length); |
| 81 | /// @solidity memory-safe-assembly |
| 82 | assembly { |
| 83 | // Selector of `log(bytes)`. |
| 84 | mstore(add(offset, 0x00), 0x0be77f56) |
| 85 | mstore(add(offset, 0x20), 0x20) |
| 86 | mstore(add(offset, 0x40), length) |
| 87 | } |
| 88 | _sendLogPayload(offset + 0x1c, length + 0x44); |
| 89 | _memcopy(offset + 0x60, offset, length); |
| 90 | /// @solidity memory-safe-assembly |
| 91 | assembly { |
| 92 | mstore(add(endOffset, 0x00), m0) |
| 93 | mstore(add(endOffset, 0x20), m1) |
| 94 | mstore(add(endOffset, 0x40), m2) |
| 95 | } |
| 96 | } |
| 97 | } |
| 98 | |
| 99 | function log(address p0) internal pure { |
| 100 | bytes32 m0; |
| 101 | bytes32 m1; |
| 102 | /// @solidity memory-safe-assembly |
| 103 | assembly { |
| 104 | m0 := mload(0x00) |
| 105 | m1 := mload(0x20) |
| 106 | // Selector of `log(address)`. |
| 107 | mstore(0x00, 0x2c2ecbc2) |
| 108 | mstore(0x20, p0) |
| 109 | } |
| 110 | _sendLogPayload(0x1c, 0x24); |
| 111 | /// @solidity memory-safe-assembly |
| 112 | assembly { |
| 113 | mstore(0x00, m0) |
| 114 | mstore(0x20, m1) |
| 115 | } |
| 116 | } |
| 117 | |
| 118 | function log(bool p0) internal pure { |
| 119 | bytes32 m0; |
| 120 | bytes32 m1; |
| 121 | /// @solidity memory-safe-assembly |
| 122 | assembly { |
| 123 | m0 := mload(0x00) |
| 124 | m1 := mload(0x20) |
| 125 | // Selector of `log(bool)`. |
| 126 | mstore(0x00, 0x32458eed) |
| 127 | mstore(0x20, p0) |
| 128 | } |
| 129 | _sendLogPayload(0x1c, 0x24); |
| 130 | /// @solidity memory-safe-assembly |
| 131 | assembly { |
| 132 | mstore(0x00, m0) |
| 133 | mstore(0x20, m1) |
| 134 | } |
| 135 | } |
| 136 | |
| 137 | function log(uint256 p0) internal pure { |
| 138 | bytes32 m0; |
| 139 | bytes32 m1; |
| 140 | /// @solidity memory-safe-assembly |
| 141 | assembly { |
| 142 | m0 := mload(0x00) |
| 143 | m1 := mload(0x20) |
| 144 | // Selector of `log(uint256)`. |
| 145 | mstore(0x00, 0xf82c50f1) |
| 146 | mstore(0x20, p0) |
| 147 | } |
| 148 | _sendLogPayload(0x1c, 0x24); |
| 149 | /// @solidity memory-safe-assembly |
| 150 | assembly { |
| 151 | mstore(0x00, m0) |
| 152 | mstore(0x20, m1) |
| 153 | } |
| 154 | } |
| 155 | |
| 156 | function log(bytes32 p0) internal pure { |
| 157 | bytes32 m0; |
| 158 | bytes32 m1; |
| 159 | bytes32 m2; |
| 160 | bytes32 m3; |
| 161 | /// @solidity memory-safe-assembly |
| 162 | assembly { |
| 163 | function writeString(pos, w) { |
| 164 | let length := 0 |
| 165 | for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } |
| 166 | mstore(pos, length) |
| 167 | let shift := sub(256, shl(3, length)) |
| 168 | mstore(add(pos, 0x20), shl(shift, shr(shift, w))) |
| 169 | } |
| 170 | m0 := mload(0x00) |
| 171 | m1 := mload(0x20) |
| 172 | m2 := mload(0x40) |
| 173 | m3 := mload(0x60) |
| 174 | // Selector of `log(string)`. |
| 175 | mstore(0x00, 0x41304fac) |
| 176 | mstore(0x20, 0x20) |
| 177 | writeString(0x40, p0) |
| 178 | } |
| 179 | _sendLogPayload(0x1c, 0x64); |
| 180 | /// @solidity memory-safe-assembly |
| 181 | assembly { |
| 182 | mstore(0x00, m0) |
| 183 | mstore(0x20, m1) |
| 184 | mstore(0x40, m2) |
| 185 | mstore(0x60, m3) |
| 186 | } |
| 187 | } |
| 188 | |
| 189 | function log(address p0, address p1) internal pure { |
| 190 | bytes32 m0; |
| 191 | bytes32 m1; |
| 192 | bytes32 m2; |
| 193 | /// @solidity memory-safe-assembly |
| 194 | assembly { |
| 195 | m0 := mload(0x00) |
| 196 | m1 := mload(0x20) |
| 197 | m2 := mload(0x40) |
| 198 | // Selector of `log(address,address)`. |
| 199 | mstore(0x00, 0xdaf0d4aa) |
| 200 | mstore(0x20, p0) |
| 201 | mstore(0x40, p1) |
| 202 | } |
| 203 | _sendLogPayload(0x1c, 0x44); |
| 204 | /// @solidity memory-safe-assembly |
| 205 | assembly { |
| 206 | mstore(0x00, m0) |
| 207 | mstore(0x20, m1) |
| 208 | mstore(0x40, m2) |
| 209 | } |
| 210 | } |
| 211 | |
| 212 | function log(address p0, bool p1) internal pure { |
| 213 | bytes32 m0; |
| 214 | bytes32 m1; |
| 215 | bytes32 m2; |
| 216 | /// @solidity memory-safe-assembly |
| 217 | assembly { |
| 218 | m0 := mload(0x00) |
| 219 | m1 := mload(0x20) |
| 220 | m2 := mload(0x40) |
| 221 | // Selector of `log(address,bool)`. |
| 222 | mstore(0x00, 0x75b605d3) |
| 223 | mstore(0x20, p0) |
| 224 | mstore(0x40, p1) |
| 225 | } |
| 226 | _sendLogPayload(0x1c, 0x44); |
| 227 | /// @solidity memory-safe-assembly |
| 228 | assembly { |
| 229 | mstore(0x00, m0) |
| 230 | mstore(0x20, m1) |
| 231 | mstore(0x40, m2) |
| 232 | } |
| 233 | } |
| 234 | |
| 235 | function log(address p0, uint256 p1) internal pure { |
| 236 | bytes32 m0; |
| 237 | bytes32 m1; |
| 238 | bytes32 m2; |
| 239 | /// @solidity memory-safe-assembly |
| 240 | assembly { |
| 241 | m0 := mload(0x00) |
| 242 | m1 := mload(0x20) |
| 243 | m2 := mload(0x40) |
| 244 | // Selector of `log(address,uint256)`. |
| 245 | mstore(0x00, 0x8309e8a8) |
| 246 | mstore(0x20, p0) |
| 247 | mstore(0x40, p1) |
| 248 | } |
| 249 | _sendLogPayload(0x1c, 0x44); |
| 250 | /// @solidity memory-safe-assembly |
| 251 | assembly { |
| 252 | mstore(0x00, m0) |
| 253 | mstore(0x20, m1) |
| 254 | mstore(0x40, m2) |
| 255 | } |
| 256 | } |
| 257 | |
| 258 | function log(address p0, bytes32 p1) internal pure { |
| 259 | bytes32 m0; |
| 260 | bytes32 m1; |
| 261 | bytes32 m2; |
| 262 | bytes32 m3; |
| 263 | bytes32 m4; |
| 264 | /// @solidity memory-safe-assembly |
| 265 | assembly { |
| 266 | function writeString(pos, w) { |
| 267 | let length := 0 |
| 268 | for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } |
| 269 | mstore(pos, length) |
| 270 | let shift := sub(256, shl(3, length)) |
| 271 | mstore(add(pos, 0x20), shl(shift, shr(shift, w))) |
| 272 | } |
| 273 | m0 := mload(0x00) |
| 274 | m1 := mload(0x20) |
| 275 | m2 := mload(0x40) |
| 276 | m3 := mload(0x60) |
| 277 | m4 := mload(0x80) |
| 278 | // Selector of `log(address,string)`. |
| 279 | mstore(0x00, 0x759f86bb) |
| 280 | mstore(0x20, p0) |
| 281 | mstore(0x40, 0x40) |
| 282 | writeString(0x60, p1) |
| 283 | } |
| 284 | _sendLogPayload(0x1c, 0x84); |
| 285 | /// @solidity memory-safe-assembly |
| 286 | assembly { |
| 287 | mstore(0x00, m0) |
| 288 | mstore(0x20, m1) |
| 289 | mstore(0x40, m2) |
| 290 | mstore(0x60, m3) |
| 291 | mstore(0x80, m4) |
| 292 | } |
| 293 | } |
| 294 | |
| 295 | function log(bool p0, address p1) internal pure { |
| 296 | bytes32 m0; |
| 297 | bytes32 m1; |
| 298 | bytes32 m2; |
| 299 | /// @solidity memory-safe-assembly |
| 300 | assembly { |
| 301 | m0 := mload(0x00) |
| 302 | m1 := mload(0x20) |
| 303 | m2 := mload(0x40) |
| 304 | // Selector of `log(bool,address)`. |
| 305 | mstore(0x00, 0x853c4849) |
| 306 | mstore(0x20, p0) |
| 307 | mstore(0x40, p1) |
| 308 | } |
| 309 | _sendLogPayload(0x1c, 0x44); |
| 310 | /// @solidity memory-safe-assembly |
| 311 | assembly { |
| 312 | mstore(0x00, m0) |
| 313 | mstore(0x20, m1) |
| 314 | mstore(0x40, m2) |
| 315 | } |
| 316 | } |
| 317 | |
| 318 | function log(bool p0, bool p1) internal pure { |
| 319 | bytes32 m0; |
| 320 | bytes32 m1; |
| 321 | bytes32 m2; |
| 322 | /// @solidity memory-safe-assembly |
| 323 | assembly { |
| 324 | m0 := mload(0x00) |
| 325 | m1 := mload(0x20) |
| 326 | m2 := mload(0x40) |
| 327 | // Selector of `log(bool,bool)`. |
| 328 | mstore(0x00, 0x2a110e83) |
| 329 | mstore(0x20, p0) |
| 330 | mstore(0x40, p1) |
| 331 | } |
| 332 | _sendLogPayload(0x1c, 0x44); |
| 333 | /// @solidity memory-safe-assembly |
| 334 | assembly { |
| 335 | mstore(0x00, m0) |
| 336 | mstore(0x20, m1) |
| 337 | mstore(0x40, m2) |
| 338 | } |
| 339 | } |
| 340 | |
| 341 | function log(bool p0, uint256 p1) internal pure { |
| 342 | bytes32 m0; |
| 343 | bytes32 m1; |
| 344 | bytes32 m2; |
| 345 | /// @solidity memory-safe-assembly |
| 346 | assembly { |
| 347 | m0 := mload(0x00) |
| 348 | m1 := mload(0x20) |
| 349 | m2 := mload(0x40) |
| 350 | // Selector of `log(bool,uint256)`. |
| 351 | mstore(0x00, 0x399174d3) |
| 352 | mstore(0x20, p0) |
| 353 | mstore(0x40, p1) |
| 354 | } |
| 355 | _sendLogPayload(0x1c, 0x44); |
| 356 | /// @solidity memory-safe-assembly |
| 357 | assembly { |
| 358 | mstore(0x00, m0) |
| 359 | mstore(0x20, m1) |
| 360 | mstore(0x40, m2) |
| 361 | } |
| 362 | } |
| 363 | |
| 364 | function log(bool p0, bytes32 p1) internal pure { |
| 365 | bytes32 m0; |
| 366 | bytes32 m1; |
| 367 | bytes32 m2; |
| 368 | bytes32 m3; |
| 369 | bytes32 m4; |
| 370 | /// @solidity memory-safe-assembly |
| 371 | assembly { |
| 372 | function writeString(pos, w) { |
| 373 | let length := 0 |
| 374 | for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } |
| 375 | mstore(pos, length) |
| 376 | let shift := sub(256, shl(3, length)) |
| 377 | mstore(add(pos, 0x20), shl(shift, shr(shift, w))) |
| 378 | } |
| 379 | m0 := mload(0x00) |
| 380 | m1 := mload(0x20) |
| 381 | m2 := mload(0x40) |
| 382 | m3 := mload(0x60) |
| 383 | m4 := mload(0x80) |
| 384 | // Selector of `log(bool,string)`. |
| 385 | mstore(0x00, 0x8feac525) |
| 386 | mstore(0x20, p0) |
| 387 | mstore(0x40, 0x40) |
| 388 | writeString(0x60, p1) |
| 389 | } |
| 390 | _sendLogPayload(0x1c, 0x84); |
| 391 | /// @solidity memory-safe-assembly |
| 392 | assembly { |
| 393 | mstore(0x00, m0) |
| 394 | mstore(0x20, m1) |
| 395 | mstore(0x40, m2) |
| 396 | mstore(0x60, m3) |
| 397 | mstore(0x80, m4) |
| 398 | } |
| 399 | } |
| 400 | |
| 401 | function log(uint256 p0, address p1) internal pure { |
| 402 | bytes32 m0; |
| 403 | bytes32 m1; |
| 404 | bytes32 m2; |
| 405 | /// @solidity memory-safe-assembly |
| 406 | assembly { |
| 407 | m0 := mload(0x00) |
| 408 | m1 := mload(0x20) |
| 409 | m2 := mload(0x40) |
| 410 | // Selector of `log(uint256,address)`. |
| 411 | mstore(0x00, 0x69276c86) |
| 412 | mstore(0x20, p0) |
| 413 | mstore(0x40, p1) |
| 414 | } |
| 415 | _sendLogPayload(0x1c, 0x44); |
| 416 | /// @solidity memory-safe-assembly |
| 417 | assembly { |
| 418 | mstore(0x00, m0) |
| 419 | mstore(0x20, m1) |
| 420 | mstore(0x40, m2) |
| 421 | } |
| 422 | } |
| 423 | |
| 424 | function log(uint256 p0, bool p1) internal pure { |
| 425 | bytes32 m0; |
| 426 | bytes32 m1; |
| 427 | bytes32 m2; |
| 428 | /// @solidity memory-safe-assembly |
| 429 | assembly { |
| 430 | m0 := mload(0x00) |
| 431 | m1 := mload(0x20) |
| 432 | m2 := mload(0x40) |
| 433 | // Selector of `log(uint256,bool)`. |
| 434 | mstore(0x00, 0x1c9d7eb3) |
| 435 | mstore(0x20, p0) |
| 436 | mstore(0x40, p1) |
| 437 | } |
| 438 | _sendLogPayload(0x1c, 0x44); |
| 439 | /// @solidity memory-safe-assembly |
| 440 | assembly { |
| 441 | mstore(0x00, m0) |
| 442 | mstore(0x20, m1) |
| 443 | mstore(0x40, m2) |
| 444 | } |
| 445 | } |
| 446 | |
| 447 | function log(uint256 p0, uint256 p1) internal pure { |
| 448 | bytes32 m0; |
| 449 | bytes32 m1; |
| 450 | bytes32 m2; |
| 451 | /// @solidity memory-safe-assembly |
| 452 | assembly { |
| 453 | m0 := mload(0x00) |
| 454 | m1 := mload(0x20) |
| 455 | m2 := mload(0x40) |
| 456 | // Selector of `log(uint256,uint256)`. |
| 457 | mstore(0x00, 0xf666715a) |
| 458 | mstore(0x20, p0) |
| 459 | mstore(0x40, p1) |
| 460 | } |
| 461 | _sendLogPayload(0x1c, 0x44); |
| 462 | /// @solidity memory-safe-assembly |
| 463 | assembly { |
| 464 | mstore(0x00, m0) |
| 465 | mstore(0x20, m1) |
| 466 | mstore(0x40, m2) |
| 467 | } |
| 468 | } |
| 469 | |
| 470 | function log(uint256 p0, bytes32 p1) internal pure { |
| 471 | bytes32 m0; |
| 472 | bytes32 m1; |
| 473 | bytes32 m2; |
| 474 | bytes32 m3; |
| 475 | bytes32 m4; |
| 476 | /// @solidity memory-safe-assembly |
| 477 | assembly { |
| 478 | function writeString(pos, w) { |
| 479 | let length := 0 |
| 480 | for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } |
| 481 | mstore(pos, length) |
| 482 | let shift := sub(256, shl(3, length)) |
| 483 | mstore(add(pos, 0x20), shl(shift, shr(shift, w))) |
| 484 | } |
| 485 | m0 := mload(0x00) |
| 486 | m1 := mload(0x20) |
| 487 | m2 := mload(0x40) |
| 488 | m3 := mload(0x60) |
| 489 | m4 := mload(0x80) |
| 490 | // Selector of `log(uint256,string)`. |
| 491 | mstore(0x00, 0x643fd0df) |
| 492 | mstore(0x20, p0) |
| 493 | mstore(0x40, 0x40) |
| 494 | writeString(0x60, p1) |
| 495 | } |
| 496 | _sendLogPayload(0x1c, 0x84); |
| 497 | /// @solidity memory-safe-assembly |
| 498 | assembly { |
| 499 | mstore(0x00, m0) |
| 500 | mstore(0x20, m1) |
| 501 | mstore(0x40, m2) |
| 502 | mstore(0x60, m3) |
| 503 | mstore(0x80, m4) |
| 504 | } |
| 505 | } |
| 506 | |
| 507 | function log(bytes32 p0, address p1) internal pure { |
| 508 | bytes32 m0; |
| 509 | bytes32 m1; |
| 510 | bytes32 m2; |
| 511 | bytes32 m3; |
| 512 | bytes32 m4; |
| 513 | /// @solidity memory-safe-assembly |
| 514 | assembly { |
| 515 | function writeString(pos, w) { |
| 516 | let length := 0 |
| 517 | for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } |
| 518 | mstore(pos, length) |
| 519 | let shift := sub(256, shl(3, length)) |
| 520 | mstore(add(pos, 0x20), shl(shift, shr(shift, w))) |
| 521 | } |
| 522 | m0 := mload(0x00) |
| 523 | m1 := mload(0x20) |
| 524 | m2 := mload(0x40) |
| 525 | m3 := mload(0x60) |
| 526 | m4 := mload(0x80) |
| 527 | // Selector of `log(string,address)`. |
| 528 | mstore(0x00, 0x319af333) |
| 529 | mstore(0x20, 0x40) |
| 530 | mstore(0x40, p1) |
| 531 | writeString(0x60, p0) |
| 532 | } |
| 533 | _sendLogPayload(0x1c, 0x84); |
| 534 | /// @solidity memory-safe-assembly |
| 535 | assembly { |
| 536 | mstore(0x00, m0) |
| 537 | mstore(0x20, m1) |
| 538 | mstore(0x40, m2) |
| 539 | mstore(0x60, m3) |
| 540 | mstore(0x80, m4) |
| 541 | } |
| 542 | } |
| 543 | |
| 544 | function log(bytes32 p0, bool p1) internal pure { |
| 545 | bytes32 m0; |
| 546 | bytes32 m1; |
| 547 | bytes32 m2; |
| 548 | bytes32 m3; |
| 549 | bytes32 m4; |
| 550 | /// @solidity memory-safe-assembly |
| 551 | assembly { |
| 552 | function writeString(pos, w) { |
| 553 | let length := 0 |
| 554 | for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } |
| 555 | mstore(pos, length) |
| 556 | let shift := sub(256, shl(3, length)) |
| 557 | mstore(add(pos, 0x20), shl(shift, shr(shift, w))) |
| 558 | } |
| 559 | m0 := mload(0x00) |
| 560 | m1 := mload(0x20) |
| 561 | m2 := mload(0x40) |
| 562 | m3 := mload(0x60) |
| 563 | m4 := mload(0x80) |
| 564 | // Selector of `log(string,bool)`. |
| 565 | mstore(0x00, 0xc3b55635) |
| 566 | mstore(0x20, 0x40) |
| 567 | mstore(0x40, p1) |
| 568 | writeString(0x60, p0) |
| 569 | } |
| 570 | _sendLogPayload(0x1c, 0x84); |
| 571 | /// @solidity memory-safe-assembly |
| 572 | assembly { |
| 573 | mstore(0x00, m0) |
| 574 | mstore(0x20, m1) |
| 575 | mstore(0x40, m2) |
| 576 | mstore(0x60, m3) |
| 577 | mstore(0x80, m4) |
| 578 | } |
| 579 | } |
| 580 | |
| 581 | function log(bytes32 p0, uint256 p1) internal pure { |
| 582 | bytes32 m0; |
| 583 | bytes32 m1; |
| 584 | bytes32 m2; |
| 585 | bytes32 m3; |
| 586 | bytes32 m4; |
| 587 | /// @solidity memory-safe-assembly |
| 588 | assembly { |
| 589 | function writeString(pos, w) { |
| 590 | let length := 0 |
| 591 | for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } |
| 592 | mstore(pos, length) |
| 593 | let shift := sub(256, shl(3, length)) |
| 594 | mstore(add(pos, 0x20), shl(shift, shr(shift, w))) |
| 595 | } |
| 596 | m0 := mload(0x00) |
| 597 | m1 := mload(0x20) |
| 598 | m2 := mload(0x40) |
| 599 | m3 := mload(0x60) |
| 600 | m4 := mload(0x80) |
| 601 | // Selector of `log(string,uint256)`. |
| 602 | mstore(0x00, 0xb60e72cc) |
| 603 | mstore(0x20, 0x40) |
| 604 | mstore(0x40, p1) |
| 605 | writeString(0x60, p0) |
| 606 | } |
| 607 | _sendLogPayload(0x1c, 0x84); |
| 608 | /// @solidity memory-safe-assembly |
| 609 | assembly { |
| 610 | mstore(0x00, m0) |
| 611 | mstore(0x20, m1) |
| 612 | mstore(0x40, m2) |
| 613 | mstore(0x60, m3) |
| 614 | mstore(0x80, m4) |
| 615 | } |
| 616 | } |
| 617 | |
| 618 | function log(bytes32 p0, bytes32 p1) internal pure { |
| 619 | bytes32 m0; |
| 620 | bytes32 m1; |
| 621 | bytes32 m2; |
| 622 | bytes32 m3; |
| 623 | bytes32 m4; |
| 624 | bytes32 m5; |
| 625 | bytes32 m6; |
| 626 | /// @solidity memory-safe-assembly |
| 627 | assembly { |
| 628 | function writeString(pos, w) { |
| 629 | let length := 0 |
| 630 | for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } |
| 631 | mstore(pos, length) |
| 632 | let shift := sub(256, shl(3, length)) |
| 633 | mstore(add(pos, 0x20), shl(shift, shr(shift, w))) |
| 634 | } |
| 635 | m0 := mload(0x00) |
| 636 | m1 := mload(0x20) |
| 637 | m2 := mload(0x40) |
| 638 | m3 := mload(0x60) |
| 639 | m4 := mload(0x80) |
| 640 | m5 := mload(0xa0) |
| 641 | m6 := mload(0xc0) |
| 642 | // Selector of `log(string,string)`. |
| 643 | mstore(0x00, 0x4b5c4277) |
| 644 | mstore(0x20, 0x40) |
| 645 | mstore(0x40, 0x80) |
| 646 | writeString(0x60, p0) |
| 647 | writeString(0xa0, p1) |
| 648 | } |
| 649 | _sendLogPayload(0x1c, 0xc4); |
| 650 | /// @solidity memory-safe-assembly |
| 651 | assembly { |
| 652 | mstore(0x00, m0) |
| 653 | mstore(0x20, m1) |
| 654 | mstore(0x40, m2) |
| 655 | mstore(0x60, m3) |
| 656 | mstore(0x80, m4) |
| 657 | mstore(0xa0, m5) |
| 658 | mstore(0xc0, m6) |
| 659 | } |
| 660 | } |
| 661 | |
| 662 | function log(address p0, address p1, address p2) internal pure { |
| 663 | bytes32 m0; |
| 664 | bytes32 m1; |
| 665 | bytes32 m2; |
| 666 | bytes32 m3; |
| 667 | /// @solidity memory-safe-assembly |
| 668 | assembly { |
| 669 | m0 := mload(0x00) |
| 670 | m1 := mload(0x20) |
| 671 | m2 := mload(0x40) |
| 672 | m3 := mload(0x60) |
| 673 | // Selector of `log(address,address,address)`. |
| 674 | mstore(0x00, 0x018c84c2) |
| 675 | mstore(0x20, p0) |
| 676 | mstore(0x40, p1) |
| 677 | mstore(0x60, p2) |
| 678 | } |
| 679 | _sendLogPayload(0x1c, 0x64); |
| 680 | /// @solidity memory-safe-assembly |
| 681 | assembly { |
| 682 | mstore(0x00, m0) |
| 683 | mstore(0x20, m1) |
| 684 | mstore(0x40, m2) |
| 685 | mstore(0x60, m3) |
| 686 | } |
| 687 | } |
| 688 | |
| 689 | function log(address p0, address p1, bool p2) internal pure { |
| 690 | bytes32 m0; |
| 691 | bytes32 m1; |
| 692 | bytes32 m2; |
| 693 | bytes32 m3; |
| 694 | /// @solidity memory-safe-assembly |
| 695 | assembly { |
| 696 | m0 := mload(0x00) |
| 697 | m1 := mload(0x20) |
| 698 | m2 := mload(0x40) |
| 699 | m3 := mload(0x60) |
| 700 | // Selector of `log(address,address,bool)`. |
| 701 | mstore(0x00, 0xf2a66286) |
| 702 | mstore(0x20, p0) |
| 703 | mstore(0x40, p1) |
| 704 | mstore(0x60, p2) |
| 705 | } |
| 706 | _sendLogPayload(0x1c, 0x64); |
| 707 | /// @solidity memory-safe-assembly |
| 708 | assembly { |
| 709 | mstore(0x00, m0) |
| 710 | mstore(0x20, m1) |
| 711 | mstore(0x40, m2) |
| 712 | mstore(0x60, m3) |
| 713 | } |
| 714 | } |
| 715 | |
| 716 | function log(address p0, address p1, uint256 p2) internal pure { |
| 717 | bytes32 m0; |
| 718 | bytes32 m1; |
| 719 | bytes32 m2; |
| 720 | bytes32 m3; |
| 721 | /// @solidity memory-safe-assembly |
| 722 | assembly { |
| 723 | m0 := mload(0x00) |
| 724 | m1 := mload(0x20) |
| 725 | m2 := mload(0x40) |
| 726 | m3 := mload(0x60) |
| 727 | // Selector of `log(address,address,uint256)`. |
| 728 | mstore(0x00, 0x17fe6185) |
| 729 | mstore(0x20, p0) |
| 730 | mstore(0x40, p1) |
| 731 | mstore(0x60, p2) |
| 732 | } |
| 733 | _sendLogPayload(0x1c, 0x64); |
| 734 | /// @solidity memory-safe-assembly |
| 735 | assembly { |
| 736 | mstore(0x00, m0) |
| 737 | mstore(0x20, m1) |
| 738 | mstore(0x40, m2) |
| 739 | mstore(0x60, m3) |
| 740 | } |
| 741 | } |
| 742 | |
| 743 | function log(address p0, address p1, bytes32 p2) internal pure { |
| 744 | bytes32 m0; |
| 745 | bytes32 m1; |
| 746 | bytes32 m2; |
| 747 | bytes32 m3; |
| 748 | bytes32 m4; |
| 749 | bytes32 m5; |
| 750 | /// @solidity memory-safe-assembly |
| 751 | assembly { |
| 752 | function writeString(pos, w) { |
| 753 | let length := 0 |
| 754 | for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } |
| 755 | mstore(pos, length) |
| 756 | let shift := sub(256, shl(3, length)) |
| 757 | mstore(add(pos, 0x20), shl(shift, shr(shift, w))) |
| 758 | } |
| 759 | m0 := mload(0x00) |
| 760 | m1 := mload(0x20) |
| 761 | m2 := mload(0x40) |
| 762 | m3 := mload(0x60) |
| 763 | m4 := mload(0x80) |
| 764 | m5 := mload(0xa0) |
| 765 | // Selector of `log(address,address,string)`. |
| 766 | mstore(0x00, 0x007150be) |
| 767 | mstore(0x20, p0) |
| 768 | mstore(0x40, p1) |
| 769 | mstore(0x60, 0x60) |
| 770 | writeString(0x80, p2) |
| 771 | } |
| 772 | _sendLogPayload(0x1c, 0xa4); |
| 773 | /// @solidity memory-safe-assembly |
| 774 | assembly { |
| 775 | mstore(0x00, m0) |
| 776 | mstore(0x20, m1) |
| 777 | mstore(0x40, m2) |
| 778 | mstore(0x60, m3) |
| 779 | mstore(0x80, m4) |
| 780 | mstore(0xa0, m5) |
| 781 | } |
| 782 | } |
| 783 | |
| 784 | function log(address p0, bool p1, address p2) internal pure { |
| 785 | bytes32 m0; |
| 786 | bytes32 m1; |
| 787 | bytes32 m2; |
| 788 | bytes32 m3; |
| 789 | /// @solidity memory-safe-assembly |
| 790 | assembly { |
| 791 | m0 := mload(0x00) |
| 792 | m1 := mload(0x20) |
| 793 | m2 := mload(0x40) |
| 794 | m3 := mload(0x60) |
| 795 | // Selector of `log(address,bool,address)`. |
| 796 | mstore(0x00, 0xf11699ed) |
| 797 | mstore(0x20, p0) |
| 798 | mstore(0x40, p1) |
| 799 | mstore(0x60, p2) |
| 800 | } |
| 801 | _sendLogPayload(0x1c, 0x64); |
| 802 | /// @solidity memory-safe-assembly |
| 803 | assembly { |
| 804 | mstore(0x00, m0) |
| 805 | mstore(0x20, m1) |
| 806 | mstore(0x40, m2) |
| 807 | mstore(0x60, m3) |
| 808 | } |
| 809 | } |
| 810 | |
| 811 | function log(address p0, bool p1, bool p2) internal pure { |
| 812 | bytes32 m0; |
| 813 | bytes32 m1; |
| 814 | bytes32 m2; |
| 815 | bytes32 m3; |
| 816 | /// @solidity memory-safe-assembly |
| 817 | assembly { |
| 818 | m0 := mload(0x00) |
| 819 | m1 := mload(0x20) |
| 820 | m2 := mload(0x40) |
| 821 | m3 := mload(0x60) |
| 822 | // Selector of `log(address,bool,bool)`. |
| 823 | mstore(0x00, 0xeb830c92) |
| 824 | mstore(0x20, p0) |
| 825 | mstore(0x40, p1) |
| 826 | mstore(0x60, p2) |
| 827 | } |
| 828 | _sendLogPayload(0x1c, 0x64); |
| 829 | /// @solidity memory-safe-assembly |
| 830 | assembly { |
| 831 | mstore(0x00, m0) |
| 832 | mstore(0x20, m1) |
| 833 | mstore(0x40, m2) |
| 834 | mstore(0x60, m3) |
| 835 | } |
| 836 | } |
| 837 | |
| 838 | function log(address p0, bool p1, uint256 p2) internal pure { |
| 839 | bytes32 m0; |
| 840 | bytes32 m1; |
| 841 | bytes32 m2; |
| 842 | bytes32 m3; |
| 843 | /// @solidity memory-safe-assembly |
| 844 | assembly { |
| 845 | m0 := mload(0x00) |
| 846 | m1 := mload(0x20) |
| 847 | m2 := mload(0x40) |
| 848 | m3 := mload(0x60) |
| 849 | // Selector of `log(address,bool,uint256)`. |
| 850 | mstore(0x00, 0x9c4f99fb) |
| 851 | mstore(0x20, p0) |
| 852 | mstore(0x40, p1) |
| 853 | mstore(0x60, p2) |
| 854 | } |
| 855 | _sendLogPayload(0x1c, 0x64); |
| 856 | /// @solidity memory-safe-assembly |
| 857 | assembly { |
| 858 | mstore(0x00, m0) |
| 859 | mstore(0x20, m1) |
| 860 | mstore(0x40, m2) |
| 861 | mstore(0x60, m3) |
| 862 | } |
| 863 | } |
| 864 | |
| 865 | function log(address p0, bool p1, bytes32 p2) internal pure { |
| 866 | bytes32 m0; |
| 867 | bytes32 m1; |
| 868 | bytes32 m2; |
| 869 | bytes32 m3; |
| 870 | bytes32 m4; |
| 871 | bytes32 m5; |
| 872 | /// @solidity memory-safe-assembly |
| 873 | assembly { |
| 874 | function writeString(pos, w) { |
| 875 | let length := 0 |
| 876 | for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } |
| 877 | mstore(pos, length) |
| 878 | let shift := sub(256, shl(3, length)) |
| 879 | mstore(add(pos, 0x20), shl(shift, shr(shift, w))) |
| 880 | } |
| 881 | m0 := mload(0x00) |
| 882 | m1 := mload(0x20) |
| 883 | m2 := mload(0x40) |
| 884 | m3 := mload(0x60) |
| 885 | m4 := mload(0x80) |
| 886 | m5 := mload(0xa0) |
| 887 | // Selector of `log(address,bool,string)`. |
| 888 | mstore(0x00, 0x212255cc) |
| 889 | mstore(0x20, p0) |
| 890 | mstore(0x40, p1) |
| 891 | mstore(0x60, 0x60) |
| 892 | writeString(0x80, p2) |
| 893 | } |
| 894 | _sendLogPayload(0x1c, 0xa4); |
| 895 | /// @solidity memory-safe-assembly |
| 896 | assembly { |
| 897 | mstore(0x00, m0) |
| 898 | mstore(0x20, m1) |
| 899 | mstore(0x40, m2) |
| 900 | mstore(0x60, m3) |
| 901 | mstore(0x80, m4) |
| 902 | mstore(0xa0, m5) |
| 903 | } |
| 904 | } |
| 905 | |
| 906 | function log(address p0, uint256 p1, address p2) internal pure { |
| 907 | bytes32 m0; |
| 908 | bytes32 m1; |
| 909 | bytes32 m2; |
| 910 | bytes32 m3; |
| 911 | /// @solidity memory-safe-assembly |
| 912 | assembly { |
| 913 | m0 := mload(0x00) |
| 914 | m1 := mload(0x20) |
| 915 | m2 := mload(0x40) |
| 916 | m3 := mload(0x60) |
| 917 | // Selector of `log(address,uint256,address)`. |
| 918 | mstore(0x00, 0x7bc0d848) |
| 919 | mstore(0x20, p0) |
| 920 | mstore(0x40, p1) |
| 921 | mstore(0x60, p2) |
| 922 | } |
| 923 | _sendLogPayload(0x1c, 0x64); |
| 924 | /// @solidity memory-safe-assembly |
| 925 | assembly { |
| 926 | mstore(0x00, m0) |
| 927 | mstore(0x20, m1) |
| 928 | mstore(0x40, m2) |
| 929 | mstore(0x60, m3) |
| 930 | } |
| 931 | } |
| 932 | |
| 933 | function log(address p0, uint256 p1, bool p2) internal pure { |
| 934 | bytes32 m0; |
| 935 | bytes32 m1; |
| 936 | bytes32 m2; |
| 937 | bytes32 m3; |
| 938 | /// @solidity memory-safe-assembly |
| 939 | assembly { |
| 940 | m0 := mload(0x00) |
| 941 | m1 := mload(0x20) |
| 942 | m2 := mload(0x40) |
| 943 | m3 := mload(0x60) |
| 944 | // Selector of `log(address,uint256,bool)`. |
| 945 | mstore(0x00, 0x678209a8) |
| 946 | mstore(0x20, p0) |
| 947 | mstore(0x40, p1) |
| 948 | mstore(0x60, p2) |
| 949 | } |
| 950 | _sendLogPayload(0x1c, 0x64); |
| 951 | /// @solidity memory-safe-assembly |
| 952 | assembly { |
| 953 | mstore(0x00, m0) |
| 954 | mstore(0x20, m1) |
| 955 | mstore(0x40, m2) |
| 956 | mstore(0x60, m3) |
| 957 | } |
| 958 | } |
| 959 | |
| 960 | function log(address p0, uint256 p1, uint256 p2) internal pure { |
| 961 | bytes32 m0; |
| 962 | bytes32 m1; |
| 963 | bytes32 m2; |
| 964 | bytes32 m3; |
| 965 | /// @solidity memory-safe-assembly |
| 966 | assembly { |
| 967 | m0 := mload(0x00) |
| 968 | m1 := mload(0x20) |
| 969 | m2 := mload(0x40) |
| 970 | m3 := mload(0x60) |
| 971 | // Selector of `log(address,uint256,uint256)`. |
| 972 | mstore(0x00, 0xb69bcaf6) |
| 973 | mstore(0x20, p0) |
| 974 | mstore(0x40, p1) |
| 975 | mstore(0x60, p2) |
| 976 | } |
| 977 | _sendLogPayload(0x1c, 0x64); |
| 978 | /// @solidity memory-safe-assembly |
| 979 | assembly { |
| 980 | mstore(0x00, m0) |
| 981 | mstore(0x20, m1) |
| 982 | mstore(0x40, m2) |
| 983 | mstore(0x60, m3) |
| 984 | } |
| 985 | } |
| 986 | |
| 987 | function log(address p0, uint256 p1, bytes32 p2) internal pure { |
| 988 | bytes32 m0; |
| 989 | bytes32 m1; |
| 990 | bytes32 m2; |
| 991 | bytes32 m3; |
| 992 | bytes32 m4; |
| 993 | bytes32 m5; |
| 994 | /// @solidity memory-safe-assembly |
| 995 | assembly { |
| 996 | function writeString(pos, w) { |
| 997 | let length := 0 |
| 998 | for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } |
| 999 | mstore(pos, length) |
| 1000 | let shift := sub(256, shl(3, length)) |
| 1001 | mstore(add(pos, 0x20), shl(shift, shr(shift, w))) |
| 1002 | } |
| 1003 | m0 := mload(0x00) |
| 1004 | m1 := mload(0x20) |
| 1005 | m2 := mload(0x40) |
| 1006 | m3 := mload(0x60) |
| 1007 | m4 := mload(0x80) |
| 1008 | m5 := mload(0xa0) |
| 1009 | // Selector of `log(address,uint256,string)`. |
| 1010 | mstore(0x00, 0xa1f2e8aa) |
| 1011 | mstore(0x20, p0) |
| 1012 | mstore(0x40, p1) |
| 1013 | mstore(0x60, 0x60) |
| 1014 | writeString(0x80, p2) |
| 1015 | } |
| 1016 | _sendLogPayload(0x1c, 0xa4); |
| 1017 | /// @solidity memory-safe-assembly |
| 1018 | assembly { |
| 1019 | mstore(0x00, m0) |
| 1020 | mstore(0x20, m1) |
| 1021 | mstore(0x40, m2) |
| 1022 | mstore(0x60, m3) |
| 1023 | mstore(0x80, m4) |
| 1024 | mstore(0xa0, m5) |
| 1025 | } |
| 1026 | } |
| 1027 | |
| 1028 | function log(address p0, bytes32 p1, address p2) internal pure { |
| 1029 | bytes32 m0; |
| 1030 | bytes32 m1; |
| 1031 | bytes32 m2; |
| 1032 | bytes32 m3; |
| 1033 | bytes32 m4; |
| 1034 | bytes32 m5; |
| 1035 | /// @solidity memory-safe-assembly |
| 1036 | assembly { |
| 1037 | function writeString(pos, w) { |
| 1038 | let length := 0 |
| 1039 | for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } |
| 1040 | mstore(pos, length) |
| 1041 | let shift := sub(256, shl(3, length)) |
| 1042 | mstore(add(pos, 0x20), shl(shift, shr(shift, w))) |
| 1043 | } |
| 1044 | m0 := mload(0x00) |
| 1045 | m1 := mload(0x20) |
| 1046 | m2 := mload(0x40) |
| 1047 | m3 := mload(0x60) |
| 1048 | m4 := mload(0x80) |
| 1049 | m5 := mload(0xa0) |
| 1050 | // Selector of `log(address,string,address)`. |
| 1051 | mstore(0x00, 0xf08744e8) |
| 1052 | mstore(0x20, p0) |
| 1053 | mstore(0x40, 0x60) |
| 1054 | mstore(0x60, p2) |
| 1055 | writeString(0x80, p1) |
| 1056 | } |
| 1057 | _sendLogPayload(0x1c, 0xa4); |
| 1058 | /// @solidity memory-safe-assembly |
| 1059 | assembly { |
| 1060 | mstore(0x00, m0) |
| 1061 | mstore(0x20, m1) |
| 1062 | mstore(0x40, m2) |
| 1063 | mstore(0x60, m3) |
| 1064 | mstore(0x80, m4) |
| 1065 | mstore(0xa0, m5) |
| 1066 | } |
| 1067 | } |
| 1068 | |
| 1069 | function log(address p0, bytes32 p1, bool p2) internal pure { |
| 1070 | bytes32 m0; |
| 1071 | bytes32 m1; |
| 1072 | bytes32 m2; |
| 1073 | bytes32 m3; |
| 1074 | bytes32 m4; |
| 1075 | bytes32 m5; |
| 1076 | /// @solidity memory-safe-assembly |
| 1077 | assembly { |
| 1078 | function writeString(pos, w) { |
| 1079 | let length := 0 |
| 1080 | for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } |
| 1081 | mstore(pos, length) |
| 1082 | let shift := sub(256, shl(3, length)) |
| 1083 | mstore(add(pos, 0x20), shl(shift, shr(shift, w))) |
| 1084 | } |
| 1085 | m0 := mload(0x00) |
| 1086 | m1 := mload(0x20) |
| 1087 | m2 := mload(0x40) |
| 1088 | m3 := mload(0x60) |
| 1089 | m4 := mload(0x80) |
| 1090 | m5 := mload(0xa0) |
| 1091 | // Selector of `log(address,string,bool)`. |
| 1092 | mstore(0x00, 0xcf020fb1) |
| 1093 | mstore(0x20, p0) |
| 1094 | mstore(0x40, 0x60) |
| 1095 | mstore(0x60, p2) |
| 1096 | writeString(0x80, p1) |
| 1097 | } |
| 1098 | _sendLogPayload(0x1c, 0xa4); |
| 1099 | /// @solidity memory-safe-assembly |
| 1100 | assembly { |
| 1101 | mstore(0x00, m0) |
| 1102 | mstore(0x20, m1) |
| 1103 | mstore(0x40, m2) |
| 1104 | mstore(0x60, m3) |
| 1105 | mstore(0x80, m4) |
| 1106 | mstore(0xa0, m5) |
| 1107 | } |
| 1108 | } |
| 1109 | |
| 1110 | function log(address p0, bytes32 p1, uint256 p2) internal pure { |
| 1111 | bytes32 m0; |
| 1112 | bytes32 m1; |
| 1113 | bytes32 m2; |
| 1114 | bytes32 m3; |
| 1115 | bytes32 m4; |
| 1116 | bytes32 m5; |
| 1117 | /// @solidity memory-safe-assembly |
| 1118 | assembly { |
| 1119 | function writeString(pos, w) { |
| 1120 | let length := 0 |
| 1121 | for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } |
| 1122 | mstore(pos, length) |
| 1123 | let shift := sub(256, shl(3, length)) |
| 1124 | mstore(add(pos, 0x20), shl(shift, shr(shift, w))) |
| 1125 | } |
| 1126 | m0 := mload(0x00) |
| 1127 | m1 := mload(0x20) |
| 1128 | m2 := mload(0x40) |
| 1129 | m3 := mload(0x60) |
| 1130 | m4 := mload(0x80) |
| 1131 | m5 := mload(0xa0) |
| 1132 | // Selector of `log(address,string,uint256)`. |
| 1133 | mstore(0x00, 0x67dd6ff1) |
| 1134 | mstore(0x20, p0) |
| 1135 | mstore(0x40, 0x60) |
| 1136 | mstore(0x60, p2) |
| 1137 | writeString(0x80, p1) |
| 1138 | } |
| 1139 | _sendLogPayload(0x1c, 0xa4); |
| 1140 | /// @solidity memory-safe-assembly |
| 1141 | assembly { |
| 1142 | mstore(0x00, m0) |
| 1143 | mstore(0x20, m1) |
| 1144 | mstore(0x40, m2) |
| 1145 | mstore(0x60, m3) |
| 1146 | mstore(0x80, m4) |
| 1147 | mstore(0xa0, m5) |
| 1148 | } |
| 1149 | } |
| 1150 | |
| 1151 | function log(address p0, bytes32 p1, bytes32 p2) internal pure { |
| 1152 | bytes32 m0; |
| 1153 | bytes32 m1; |
| 1154 | bytes32 m2; |
| 1155 | bytes32 m3; |
| 1156 | bytes32 m4; |
| 1157 | bytes32 m5; |
| 1158 | bytes32 m6; |
| 1159 | bytes32 m7; |
| 1160 | /// @solidity memory-safe-assembly |
| 1161 | assembly { |
| 1162 | function writeString(pos, w) { |
| 1163 | let length := 0 |
| 1164 | for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } |
| 1165 | mstore(pos, length) |
| 1166 | let shift := sub(256, shl(3, length)) |
| 1167 | mstore(add(pos, 0x20), shl(shift, shr(shift, w))) |
| 1168 | } |
| 1169 | m0 := mload(0x00) |
| 1170 | m1 := mload(0x20) |
| 1171 | m2 := mload(0x40) |
| 1172 | m3 := mload(0x60) |
| 1173 | m4 := mload(0x80) |
| 1174 | m5 := mload(0xa0) |
| 1175 | m6 := mload(0xc0) |
| 1176 | m7 := mload(0xe0) |
| 1177 | // Selector of `log(address,string,string)`. |
| 1178 | mstore(0x00, 0xfb772265) |
| 1179 | mstore(0x20, p0) |
| 1180 | mstore(0x40, 0x60) |
| 1181 | mstore(0x60, 0xa0) |
| 1182 | writeString(0x80, p1) |
| 1183 | writeString(0xc0, p2) |
| 1184 | } |
| 1185 | _sendLogPayload(0x1c, 0xe4); |
| 1186 | /// @solidity memory-safe-assembly |
| 1187 | assembly { |
| 1188 | mstore(0x00, m0) |
| 1189 | mstore(0x20, m1) |
| 1190 | mstore(0x40, m2) |
| 1191 | mstore(0x60, m3) |
| 1192 | mstore(0x80, m4) |
| 1193 | mstore(0xa0, m5) |
| 1194 | mstore(0xc0, m6) |
| 1195 | mstore(0xe0, m7) |
| 1196 | } |
| 1197 | } |
| 1198 | |
| 1199 | function log(bool p0, address p1, address p2) internal pure { |
| 1200 | bytes32 m0; |
| 1201 | bytes32 m1; |
| 1202 | bytes32 m2; |
| 1203 | bytes32 m3; |
| 1204 | /// @solidity memory-safe-assembly |
| 1205 | assembly { |
| 1206 | m0 := mload(0x00) |
| 1207 | m1 := mload(0x20) |
| 1208 | m2 := mload(0x40) |
| 1209 | m3 := mload(0x60) |
| 1210 | // Selector of `log(bool,address,address)`. |
| 1211 | mstore(0x00, 0xd2763667) |
| 1212 | mstore(0x20, p0) |
| 1213 | mstore(0x40, p1) |
| 1214 | mstore(0x60, p2) |
| 1215 | } |
| 1216 | _sendLogPayload(0x1c, 0x64); |
| 1217 | /// @solidity memory-safe-assembly |
| 1218 | assembly { |
| 1219 | mstore(0x00, m0) |
| 1220 | mstore(0x20, m1) |
| 1221 | mstore(0x40, m2) |
| 1222 | mstore(0x60, m3) |
| 1223 | } |
| 1224 | } |
| 1225 | |
| 1226 | function log(bool p0, address p1, bool p2) internal pure { |
| 1227 | bytes32 m0; |
| 1228 | bytes32 m1; |
| 1229 | bytes32 m2; |
| 1230 | bytes32 m3; |
| 1231 | /// @solidity memory-safe-assembly |
| 1232 | assembly { |
| 1233 | m0 := mload(0x00) |
| 1234 | m1 := mload(0x20) |
| 1235 | m2 := mload(0x40) |
| 1236 | m3 := mload(0x60) |
| 1237 | // Selector of `log(bool,address,bool)`. |
| 1238 | mstore(0x00, 0x18c9c746) |
| 1239 | mstore(0x20, p0) |
| 1240 | mstore(0x40, p1) |
| 1241 | mstore(0x60, p2) |
| 1242 | } |
| 1243 | _sendLogPayload(0x1c, 0x64); |
| 1244 | /// @solidity memory-safe-assembly |
| 1245 | assembly { |
| 1246 | mstore(0x00, m0) |
| 1247 | mstore(0x20, m1) |
| 1248 | mstore(0x40, m2) |
| 1249 | mstore(0x60, m3) |
| 1250 | } |
| 1251 | } |
| 1252 | |
| 1253 | function log(bool p0, address p1, uint256 p2) internal pure { |
| 1254 | bytes32 m0; |
| 1255 | bytes32 m1; |
| 1256 | bytes32 m2; |
| 1257 | bytes32 m3; |
| 1258 | /// @solidity memory-safe-assembly |
| 1259 | assembly { |
| 1260 | m0 := mload(0x00) |
| 1261 | m1 := mload(0x20) |
| 1262 | m2 := mload(0x40) |
| 1263 | m3 := mload(0x60) |
| 1264 | // Selector of `log(bool,address,uint256)`. |
| 1265 | mstore(0x00, 0x5f7b9afb) |
| 1266 | mstore(0x20, p0) |
| 1267 | mstore(0x40, p1) |
| 1268 | mstore(0x60, p2) |
| 1269 | } |
| 1270 | _sendLogPayload(0x1c, 0x64); |
| 1271 | /// @solidity memory-safe-assembly |
| 1272 | assembly { |
| 1273 | mstore(0x00, m0) |
| 1274 | mstore(0x20, m1) |
| 1275 | mstore(0x40, m2) |
| 1276 | mstore(0x60, m3) |
| 1277 | } |
| 1278 | } |
| 1279 | |
| 1280 | function log(bool p0, address p1, bytes32 p2) internal pure { |
| 1281 | bytes32 m0; |
| 1282 | bytes32 m1; |
| 1283 | bytes32 m2; |
| 1284 | bytes32 m3; |
| 1285 | bytes32 m4; |
| 1286 | bytes32 m5; |
| 1287 | /// @solidity memory-safe-assembly |
| 1288 | assembly { |
| 1289 | function writeString(pos, w) { |
| 1290 | let length := 0 |
| 1291 | for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } |
| 1292 | mstore(pos, length) |
| 1293 | let shift := sub(256, shl(3, length)) |
| 1294 | mstore(add(pos, 0x20), shl(shift, shr(shift, w))) |
| 1295 | } |
| 1296 | m0 := mload(0x00) |
| 1297 | m1 := mload(0x20) |
| 1298 | m2 := mload(0x40) |
| 1299 | m3 := mload(0x60) |
| 1300 | m4 := mload(0x80) |
| 1301 | m5 := mload(0xa0) |
| 1302 | // Selector of `log(bool,address,string)`. |
| 1303 | mstore(0x00, 0xde9a9270) |
| 1304 | mstore(0x20, p0) |
| 1305 | mstore(0x40, p1) |
| 1306 | mstore(0x60, 0x60) |
| 1307 | writeString(0x80, p2) |
| 1308 | } |
| 1309 | _sendLogPayload(0x1c, 0xa4); |
| 1310 | /// @solidity memory-safe-assembly |
| 1311 | assembly { |
| 1312 | mstore(0x00, m0) |
| 1313 | mstore(0x20, m1) |
| 1314 | mstore(0x40, m2) |
| 1315 | mstore(0x60, m3) |
| 1316 | mstore(0x80, m4) |
| 1317 | mstore(0xa0, m5) |
| 1318 | } |
| 1319 | } |
| 1320 | |
| 1321 | function log(bool p0, bool p1, address p2) internal pure { |
| 1322 | bytes32 m0; |
| 1323 | bytes32 m1; |
| 1324 | bytes32 m2; |
| 1325 | bytes32 m3; |
| 1326 | /// @solidity memory-safe-assembly |
| 1327 | assembly { |
| 1328 | m0 := mload(0x00) |
| 1329 | m1 := mload(0x20) |
| 1330 | m2 := mload(0x40) |
| 1331 | m3 := mload(0x60) |
| 1332 | // Selector of `log(bool,bool,address)`. |
| 1333 | mstore(0x00, 0x1078f68d) |
| 1334 | mstore(0x20, p0) |
| 1335 | mstore(0x40, p1) |
| 1336 | mstore(0x60, p2) |
| 1337 | } |
| 1338 | _sendLogPayload(0x1c, 0x64); |
| 1339 | /// @solidity memory-safe-assembly |
| 1340 | assembly { |
| 1341 | mstore(0x00, m0) |
| 1342 | mstore(0x20, m1) |
| 1343 | mstore(0x40, m2) |
| 1344 | mstore(0x60, m3) |
| 1345 | } |
| 1346 | } |
| 1347 | |
| 1348 | function log(bool p0, bool p1, bool p2) internal pure { |
| 1349 | bytes32 m0; |
| 1350 | bytes32 m1; |
| 1351 | bytes32 m2; |
| 1352 | bytes32 m3; |
| 1353 | /// @solidity memory-safe-assembly |
| 1354 | assembly { |
| 1355 | m0 := mload(0x00) |
| 1356 | m1 := mload(0x20) |
| 1357 | m2 := mload(0x40) |
| 1358 | m3 := mload(0x60) |
| 1359 | // Selector of `log(bool,bool,bool)`. |
| 1360 | mstore(0x00, 0x50709698) |
| 1361 | mstore(0x20, p0) |
| 1362 | mstore(0x40, p1) |
| 1363 | mstore(0x60, p2) |
| 1364 | } |
| 1365 | _sendLogPayload(0x1c, 0x64); |
| 1366 | /// @solidity memory-safe-assembly |
| 1367 | assembly { |
| 1368 | mstore(0x00, m0) |
| 1369 | mstore(0x20, m1) |
| 1370 | mstore(0x40, m2) |
| 1371 | mstore(0x60, m3) |
| 1372 | } |
| 1373 | } |
| 1374 | |
| 1375 | function log(bool p0, bool p1, uint256 p2) internal pure { |
| 1376 | bytes32 m0; |
| 1377 | bytes32 m1; |
| 1378 | bytes32 m2; |
| 1379 | bytes32 m3; |
| 1380 | /// @solidity memory-safe-assembly |
| 1381 | assembly { |
| 1382 | m0 := mload(0x00) |
| 1383 | m1 := mload(0x20) |
| 1384 | m2 := mload(0x40) |
| 1385 | m3 := mload(0x60) |
| 1386 | // Selector of `log(bool,bool,uint256)`. |
| 1387 | mstore(0x00, 0x12f21602) |
| 1388 | mstore(0x20, p0) |
| 1389 | mstore(0x40, p1) |
| 1390 | mstore(0x60, p2) |
| 1391 | } |
| 1392 | _sendLogPayload(0x1c, 0x64); |
| 1393 | /// @solidity memory-safe-assembly |
| 1394 | assembly { |
| 1395 | mstore(0x00, m0) |
| 1396 | mstore(0x20, m1) |
| 1397 | mstore(0x40, m2) |
| 1398 | mstore(0x60, m3) |
| 1399 | } |
| 1400 | } |
| 1401 | |
| 1402 | function log(bool p0, bool p1, bytes32 p2) internal pure { |
| 1403 | bytes32 m0; |
| 1404 | bytes32 m1; |
| 1405 | bytes32 m2; |
| 1406 | bytes32 m3; |
| 1407 | bytes32 m4; |
| 1408 | bytes32 m5; |
| 1409 | /// @solidity memory-safe-assembly |
| 1410 | assembly { |
| 1411 | function writeString(pos, w) { |
| 1412 | let length := 0 |
| 1413 | for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } |
| 1414 | mstore(pos, length) |
| 1415 | let shift := sub(256, shl(3, length)) |
| 1416 | mstore(add(pos, 0x20), shl(shift, shr(shift, w))) |
| 1417 | } |
| 1418 | m0 := mload(0x00) |
| 1419 | m1 := mload(0x20) |
| 1420 | m2 := mload(0x40) |
| 1421 | m3 := mload(0x60) |
| 1422 | m4 := mload(0x80) |
| 1423 | m5 := mload(0xa0) |
| 1424 | // Selector of `log(bool,bool,string)`. |
| 1425 | mstore(0x00, 0x2555fa46) |
| 1426 | mstore(0x20, p0) |
| 1427 | mstore(0x40, p1) |
| 1428 | mstore(0x60, 0x60) |
| 1429 | writeString(0x80, p2) |
| 1430 | } |
| 1431 | _sendLogPayload(0x1c, 0xa4); |
| 1432 | /// @solidity memory-safe-assembly |
| 1433 | assembly { |
| 1434 | mstore(0x00, m0) |
| 1435 | mstore(0x20, m1) |
| 1436 | mstore(0x40, m2) |
| 1437 | mstore(0x60, m3) |
| 1438 | mstore(0x80, m4) |
| 1439 | mstore(0xa0, m5) |
| 1440 | } |
| 1441 | } |
| 1442 | |
| 1443 | function log(bool p0, uint256 p1, address p2) internal pure { |
| 1444 | bytes32 m0; |
| 1445 | bytes32 m1; |
| 1446 | bytes32 m2; |
| 1447 | bytes32 m3; |
| 1448 | /// @solidity memory-safe-assembly |
| 1449 | assembly { |
| 1450 | m0 := mload(0x00) |
| 1451 | m1 := mload(0x20) |
| 1452 | m2 := mload(0x40) |
| 1453 | m3 := mload(0x60) |
| 1454 | // Selector of `log(bool,uint256,address)`. |
| 1455 | mstore(0x00, 0x088ef9d2) |
| 1456 | mstore(0x20, p0) |
| 1457 | mstore(0x40, p1) |
| 1458 | mstore(0x60, p2) |
| 1459 | } |
| 1460 | _sendLogPayload(0x1c, 0x64); |
| 1461 | /// @solidity memory-safe-assembly |
| 1462 | assembly { |
| 1463 | mstore(0x00, m0) |
| 1464 | mstore(0x20, m1) |
| 1465 | mstore(0x40, m2) |
| 1466 | mstore(0x60, m3) |
| 1467 | } |
| 1468 | } |
| 1469 | |
| 1470 | function log(bool p0, uint256 p1, bool p2) internal pure { |
| 1471 | bytes32 m0; |
| 1472 | bytes32 m1; |
| 1473 | bytes32 m2; |
| 1474 | bytes32 m3; |
| 1475 | /// @solidity memory-safe-assembly |
| 1476 | assembly { |
| 1477 | m0 := mload(0x00) |
| 1478 | m1 := mload(0x20) |
| 1479 | m2 := mload(0x40) |
| 1480 | m3 := mload(0x60) |
| 1481 | // Selector of `log(bool,uint256,bool)`. |
| 1482 | mstore(0x00, 0xe8defba9) |
| 1483 | mstore(0x20, p0) |
| 1484 | mstore(0x40, p1) |
| 1485 | mstore(0x60, p2) |
| 1486 | } |
| 1487 | _sendLogPayload(0x1c, 0x64); |
| 1488 | /// @solidity memory-safe-assembly |
| 1489 | assembly { |
| 1490 | mstore(0x00, m0) |
| 1491 | mstore(0x20, m1) |
| 1492 | mstore(0x40, m2) |
| 1493 | mstore(0x60, m3) |
| 1494 | } |
| 1495 | } |
| 1496 | |
| 1497 | function log(bool p0, uint256 p1, uint256 p2) internal pure { |
| 1498 | bytes32 m0; |
| 1499 | bytes32 m1; |
| 1500 | bytes32 m2; |
| 1501 | bytes32 m3; |
| 1502 | /// @solidity memory-safe-assembly |
| 1503 | assembly { |
| 1504 | m0 := mload(0x00) |
| 1505 | m1 := mload(0x20) |
| 1506 | m2 := mload(0x40) |
| 1507 | m3 := mload(0x60) |
| 1508 | // Selector of `log(bool,uint256,uint256)`. |
| 1509 | mstore(0x00, 0x37103367) |
| 1510 | mstore(0x20, p0) |
| 1511 | mstore(0x40, p1) |
| 1512 | mstore(0x60, p2) |
| 1513 | } |
| 1514 | _sendLogPayload(0x1c, 0x64); |
| 1515 | /// @solidity memory-safe-assembly |
| 1516 | assembly { |
| 1517 | mstore(0x00, m0) |
| 1518 | mstore(0x20, m1) |
| 1519 | mstore(0x40, m2) |
| 1520 | mstore(0x60, m3) |
| 1521 | } |
| 1522 | } |
| 1523 | |
| 1524 | function log(bool p0, uint256 p1, bytes32 p2) internal pure { |
| 1525 | bytes32 m0; |
| 1526 | bytes32 m1; |
| 1527 | bytes32 m2; |
| 1528 | bytes32 m3; |
| 1529 | bytes32 m4; |
| 1530 | bytes32 m5; |
| 1531 | /// @solidity memory-safe-assembly |
| 1532 | assembly { |
| 1533 | function writeString(pos, w) { |
| 1534 | let length := 0 |
| 1535 | for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } |
| 1536 | mstore(pos, length) |
| 1537 | let shift := sub(256, shl(3, length)) |
| 1538 | mstore(add(pos, 0x20), shl(shift, shr(shift, w))) |
| 1539 | } |
| 1540 | m0 := mload(0x00) |
| 1541 | m1 := mload(0x20) |
| 1542 | m2 := mload(0x40) |
| 1543 | m3 := mload(0x60) |
| 1544 | m4 := mload(0x80) |
| 1545 | m5 := mload(0xa0) |
| 1546 | // Selector of `log(bool,uint256,string)`. |
| 1547 | mstore(0x00, 0xc3fc3970) |
| 1548 | mstore(0x20, p0) |
| 1549 | mstore(0x40, p1) |
| 1550 | mstore(0x60, 0x60) |
| 1551 | writeString(0x80, p2) |
| 1552 | } |
| 1553 | _sendLogPayload(0x1c, 0xa4); |
| 1554 | /// @solidity memory-safe-assembly |
| 1555 | assembly { |
| 1556 | mstore(0x00, m0) |
| 1557 | mstore(0x20, m1) |
| 1558 | mstore(0x40, m2) |
| 1559 | mstore(0x60, m3) |
| 1560 | mstore(0x80, m4) |
| 1561 | mstore(0xa0, m5) |
| 1562 | } |
| 1563 | } |
| 1564 | |
| 1565 | function log(bool p0, bytes32 p1, address p2) internal pure { |
| 1566 | bytes32 m0; |
| 1567 | bytes32 m1; |
| 1568 | bytes32 m2; |
| 1569 | bytes32 m3; |
| 1570 | bytes32 m4; |
| 1571 | bytes32 m5; |
| 1572 | /// @solidity memory-safe-assembly |
| 1573 | assembly { |
| 1574 | function writeString(pos, w) { |
| 1575 | let length := 0 |
| 1576 | for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } |
| 1577 | mstore(pos, length) |
| 1578 | let shift := sub(256, shl(3, length)) |
| 1579 | mstore(add(pos, 0x20), shl(shift, shr(shift, w))) |
| 1580 | } |
| 1581 | m0 := mload(0x00) |
| 1582 | m1 := mload(0x20) |
| 1583 | m2 := mload(0x40) |
| 1584 | m3 := mload(0x60) |
| 1585 | m4 := mload(0x80) |
| 1586 | m5 := mload(0xa0) |
| 1587 | // Selector of `log(bool,string,address)`. |
| 1588 | mstore(0x00, 0x9591b953) |
| 1589 | mstore(0x20, p0) |
| 1590 | mstore(0x40, 0x60) |
| 1591 | mstore(0x60, p2) |
| 1592 | writeString(0x80, p1) |
| 1593 | } |
| 1594 | _sendLogPayload(0x1c, 0xa4); |
| 1595 | /// @solidity memory-safe-assembly |
| 1596 | assembly { |
| 1597 | mstore(0x00, m0) |
| 1598 | mstore(0x20, m1) |
| 1599 | mstore(0x40, m2) |
| 1600 | mstore(0x60, m3) |
| 1601 | mstore(0x80, m4) |
| 1602 | mstore(0xa0, m5) |
| 1603 | } |
| 1604 | } |
| 1605 | |
| 1606 | function log(bool p0, bytes32 p1, bool p2) internal pure { |
| 1607 | bytes32 m0; |
| 1608 | bytes32 m1; |
| 1609 | bytes32 m2; |
| 1610 | bytes32 m3; |
| 1611 | bytes32 m4; |
| 1612 | bytes32 m5; |
| 1613 | /// @solidity memory-safe-assembly |
| 1614 | assembly { |
| 1615 | function writeString(pos, w) { |
| 1616 | let length := 0 |
| 1617 | for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } |
| 1618 | mstore(pos, length) |
| 1619 | let shift := sub(256, shl(3, length)) |
| 1620 | mstore(add(pos, 0x20), shl(shift, shr(shift, w))) |
| 1621 | } |
| 1622 | m0 := mload(0x00) |
| 1623 | m1 := mload(0x20) |
| 1624 | m2 := mload(0x40) |
| 1625 | m3 := mload(0x60) |
| 1626 | m4 := mload(0x80) |
| 1627 | m5 := mload(0xa0) |
| 1628 | // Selector of `log(bool,string,bool)`. |
| 1629 | mstore(0x00, 0xdbb4c247) |
| 1630 | mstore(0x20, p0) |
| 1631 | mstore(0x40, 0x60) |
| 1632 | mstore(0x60, p2) |
| 1633 | writeString(0x80, p1) |
| 1634 | } |
| 1635 | _sendLogPayload(0x1c, 0xa4); |
| 1636 | /// @solidity memory-safe-assembly |
| 1637 | assembly { |
| 1638 | mstore(0x00, m0) |
| 1639 | mstore(0x20, m1) |
| 1640 | mstore(0x40, m2) |
| 1641 | mstore(0x60, m3) |
| 1642 | mstore(0x80, m4) |
| 1643 | mstore(0xa0, m5) |
| 1644 | } |
| 1645 | } |
| 1646 | |
| 1647 | function log(bool p0, bytes32 p1, uint256 p2) internal pure { |
| 1648 | bytes32 m0; |
| 1649 | bytes32 m1; |
| 1650 | bytes32 m2; |
| 1651 | bytes32 m3; |
| 1652 | bytes32 m4; |
| 1653 | bytes32 m5; |
| 1654 | /// @solidity memory-safe-assembly |
| 1655 | assembly { |
| 1656 | function writeString(pos, w) { |
| 1657 | let length := 0 |
| 1658 | for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } |
| 1659 | mstore(pos, length) |
| 1660 | let shift := sub(256, shl(3, length)) |
| 1661 | mstore(add(pos, 0x20), shl(shift, shr(shift, w))) |
| 1662 | } |
| 1663 | m0 := mload(0x00) |
| 1664 | m1 := mload(0x20) |
| 1665 | m2 := mload(0x40) |
| 1666 | m3 := mload(0x60) |
| 1667 | m4 := mload(0x80) |
| 1668 | m5 := mload(0xa0) |
| 1669 | // Selector of `log(bool,string,uint256)`. |
| 1670 | mstore(0x00, 0x1093ee11) |
| 1671 | mstore(0x20, p0) |
| 1672 | mstore(0x40, 0x60) |
| 1673 | mstore(0x60, p2) |
| 1674 | writeString(0x80, p1) |
| 1675 | } |
| 1676 | _sendLogPayload(0x1c, 0xa4); |
| 1677 | /// @solidity memory-safe-assembly |
| 1678 | assembly { |
| 1679 | mstore(0x00, m0) |
| 1680 | mstore(0x20, m1) |
| 1681 | mstore(0x40, m2) |
| 1682 | mstore(0x60, m3) |
| 1683 | mstore(0x80, m4) |
| 1684 | mstore(0xa0, m5) |
| 1685 | } |
| 1686 | } |
| 1687 | |
| 1688 | function log(bool p0, bytes32 p1, bytes32 p2) internal pure { |
| 1689 | bytes32 m0; |
| 1690 | bytes32 m1; |
| 1691 | bytes32 m2; |
| 1692 | bytes32 m3; |
| 1693 | bytes32 m4; |
| 1694 | bytes32 m5; |
| 1695 | bytes32 m6; |
| 1696 | bytes32 m7; |
| 1697 | /// @solidity memory-safe-assembly |
| 1698 | assembly { |
| 1699 | function writeString(pos, w) { |
| 1700 | let length := 0 |
| 1701 | for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } |
| 1702 | mstore(pos, length) |
| 1703 | let shift := sub(256, shl(3, length)) |
| 1704 | mstore(add(pos, 0x20), shl(shift, shr(shift, w))) |
| 1705 | } |
| 1706 | m0 := mload(0x00) |
| 1707 | m1 := mload(0x20) |
| 1708 | m2 := mload(0x40) |
| 1709 | m3 := mload(0x60) |
| 1710 | m4 := mload(0x80) |
| 1711 | m5 := mload(0xa0) |
| 1712 | m6 := mload(0xc0) |
| 1713 | m7 := mload(0xe0) |
| 1714 | // Selector of `log(bool,string,string)`. |
| 1715 | mstore(0x00, 0xb076847f) |
| 1716 | mstore(0x20, p0) |
| 1717 | mstore(0x40, 0x60) |
| 1718 | mstore(0x60, 0xa0) |
| 1719 | writeString(0x80, p1) |
| 1720 | writeString(0xc0, p2) |
| 1721 | } |
| 1722 | _sendLogPayload(0x1c, 0xe4); |
| 1723 | /// @solidity memory-safe-assembly |
| 1724 | assembly { |
| 1725 | mstore(0x00, m0) |
| 1726 | mstore(0x20, m1) |
| 1727 | mstore(0x40, m2) |
| 1728 | mstore(0x60, m3) |
| 1729 | mstore(0x80, m4) |
| 1730 | mstore(0xa0, m5) |
| 1731 | mstore(0xc0, m6) |
| 1732 | mstore(0xe0, m7) |
| 1733 | } |
| 1734 | } |
| 1735 | |
| 1736 | function log(uint256 p0, address p1, address p2) internal pure { |
| 1737 | bytes32 m0; |
| 1738 | bytes32 m1; |
| 1739 | bytes32 m2; |
| 1740 | bytes32 m3; |
| 1741 | /// @solidity memory-safe-assembly |
| 1742 | assembly { |
| 1743 | m0 := mload(0x00) |
| 1744 | m1 := mload(0x20) |
| 1745 | m2 := mload(0x40) |
| 1746 | m3 := mload(0x60) |
| 1747 | // Selector of `log(uint256,address,address)`. |
| 1748 | mstore(0x00, 0xbcfd9be0) |
| 1749 | mstore(0x20, p0) |
| 1750 | mstore(0x40, p1) |
| 1751 | mstore(0x60, p2) |
| 1752 | } |
| 1753 | _sendLogPayload(0x1c, 0x64); |
| 1754 | /// @solidity memory-safe-assembly |
| 1755 | assembly { |
| 1756 | mstore(0x00, m0) |
| 1757 | mstore(0x20, m1) |
| 1758 | mstore(0x40, m2) |
| 1759 | mstore(0x60, m3) |
| 1760 | } |
| 1761 | } |
| 1762 | |
| 1763 | function log(uint256 p0, address p1, bool p2) internal pure { |
| 1764 | bytes32 m0; |
| 1765 | bytes32 m1; |
| 1766 | bytes32 m2; |
| 1767 | bytes32 m3; |
| 1768 | /// @solidity memory-safe-assembly |
| 1769 | assembly { |
| 1770 | m0 := mload(0x00) |
| 1771 | m1 := mload(0x20) |
| 1772 | m2 := mload(0x40) |
| 1773 | m3 := mload(0x60) |
| 1774 | // Selector of `log(uint256,address,bool)`. |
| 1775 | mstore(0x00, 0x9b6ec042) |
| 1776 | mstore(0x20, p0) |
| 1777 | mstore(0x40, p1) |
| 1778 | mstore(0x60, p2) |
| 1779 | } |
| 1780 | _sendLogPayload(0x1c, 0x64); |
| 1781 | /// @solidity memory-safe-assembly |
| 1782 | assembly { |
| 1783 | mstore(0x00, m0) |
| 1784 | mstore(0x20, m1) |
| 1785 | mstore(0x40, m2) |
| 1786 | mstore(0x60, m3) |
| 1787 | } |
| 1788 | } |
| 1789 | |
| 1790 | function log(uint256 p0, address p1, uint256 p2) internal pure { |
| 1791 | bytes32 m0; |
| 1792 | bytes32 m1; |
| 1793 | bytes32 m2; |
| 1794 | bytes32 m3; |
| 1795 | /// @solidity memory-safe-assembly |
| 1796 | assembly { |
| 1797 | m0 := mload(0x00) |
| 1798 | m1 := mload(0x20) |
| 1799 | m2 := mload(0x40) |
| 1800 | m3 := mload(0x60) |
| 1801 | // Selector of `log(uint256,address,uint256)`. |
| 1802 | mstore(0x00, 0x5a9b5ed5) |
| 1803 | mstore(0x20, p0) |
| 1804 | mstore(0x40, p1) |
| 1805 | mstore(0x60, p2) |
| 1806 | } |
| 1807 | _sendLogPayload(0x1c, 0x64); |
| 1808 | /// @solidity memory-safe-assembly |
| 1809 | assembly { |
| 1810 | mstore(0x00, m0) |
| 1811 | mstore(0x20, m1) |
| 1812 | mstore(0x40, m2) |
| 1813 | mstore(0x60, m3) |
| 1814 | } |
| 1815 | } |
| 1816 | |
| 1817 | function log(uint256 p0, address p1, bytes32 p2) internal pure { |
| 1818 | bytes32 m0; |
| 1819 | bytes32 m1; |
| 1820 | bytes32 m2; |
| 1821 | bytes32 m3; |
| 1822 | bytes32 m4; |
| 1823 | bytes32 m5; |
| 1824 | /// @solidity memory-safe-assembly |
| 1825 | assembly { |
| 1826 | function writeString(pos, w) { |
| 1827 | let length := 0 |
| 1828 | for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } |
| 1829 | mstore(pos, length) |
| 1830 | let shift := sub(256, shl(3, length)) |
| 1831 | mstore(add(pos, 0x20), shl(shift, shr(shift, w))) |
| 1832 | } |
| 1833 | m0 := mload(0x00) |
| 1834 | m1 := mload(0x20) |
| 1835 | m2 := mload(0x40) |
| 1836 | m3 := mload(0x60) |
| 1837 | m4 := mload(0x80) |
| 1838 | m5 := mload(0xa0) |
| 1839 | // Selector of `log(uint256,address,string)`. |
| 1840 | mstore(0x00, 0x63cb41f9) |
| 1841 | mstore(0x20, p0) |
| 1842 | mstore(0x40, p1) |
| 1843 | mstore(0x60, 0x60) |
| 1844 | writeString(0x80, p2) |
| 1845 | } |
| 1846 | _sendLogPayload(0x1c, 0xa4); |
| 1847 | /// @solidity memory-safe-assembly |
| 1848 | assembly { |
| 1849 | mstore(0x00, m0) |
| 1850 | mstore(0x20, m1) |
| 1851 | mstore(0x40, m2) |
| 1852 | mstore(0x60, m3) |
| 1853 | mstore(0x80, m4) |
| 1854 | mstore(0xa0, m5) |
| 1855 | } |
| 1856 | } |
| 1857 | |
| 1858 | function log(uint256 p0, bool p1, address p2) internal pure { |
| 1859 | bytes32 m0; |
| 1860 | bytes32 m1; |
| 1861 | bytes32 m2; |
| 1862 | bytes32 m3; |
| 1863 | /// @solidity memory-safe-assembly |
| 1864 | assembly { |
| 1865 | m0 := mload(0x00) |
| 1866 | m1 := mload(0x20) |
| 1867 | m2 := mload(0x40) |
| 1868 | m3 := mload(0x60) |
| 1869 | // Selector of `log(uint256,bool,address)`. |
| 1870 | mstore(0x00, 0x35085f7b) |
| 1871 | mstore(0x20, p0) |
| 1872 | mstore(0x40, p1) |
| 1873 | mstore(0x60, p2) |
| 1874 | } |
| 1875 | _sendLogPayload(0x1c, 0x64); |
| 1876 | /// @solidity memory-safe-assembly |
| 1877 | assembly { |
| 1878 | mstore(0x00, m0) |
| 1879 | mstore(0x20, m1) |
| 1880 | mstore(0x40, m2) |
| 1881 | mstore(0x60, m3) |
| 1882 | } |
| 1883 | } |
| 1884 | |
| 1885 | function log(uint256 p0, bool p1, bool p2) internal pure { |
| 1886 | bytes32 m0; |
| 1887 | bytes32 m1; |
| 1888 | bytes32 m2; |
| 1889 | bytes32 m3; |
| 1890 | /// @solidity memory-safe-assembly |
| 1891 | assembly { |
| 1892 | m0 := mload(0x00) |
| 1893 | m1 := mload(0x20) |
| 1894 | m2 := mload(0x40) |
| 1895 | m3 := mload(0x60) |
| 1896 | // Selector of `log(uint256,bool,bool)`. |
| 1897 | mstore(0x00, 0x20718650) |
| 1898 | mstore(0x20, p0) |
| 1899 | mstore(0x40, p1) |
| 1900 | mstore(0x60, p2) |
| 1901 | } |
| 1902 | _sendLogPayload(0x1c, 0x64); |
| 1903 | /// @solidity memory-safe-assembly |
| 1904 | assembly { |
| 1905 | mstore(0x00, m0) |
| 1906 | mstore(0x20, m1) |
| 1907 | mstore(0x40, m2) |
| 1908 | mstore(0x60, m3) |
| 1909 | } |
| 1910 | } |
| 1911 | |
| 1912 | function log(uint256 p0, bool p1, uint256 p2) internal pure { |
| 1913 | bytes32 m0; |
| 1914 | bytes32 m1; |
| 1915 | bytes32 m2; |
| 1916 | bytes32 m3; |
| 1917 | /// @solidity memory-safe-assembly |
| 1918 | assembly { |
| 1919 | m0 := mload(0x00) |
| 1920 | m1 := mload(0x20) |
| 1921 | m2 := mload(0x40) |
| 1922 | m3 := mload(0x60) |
| 1923 | // Selector of `log(uint256,bool,uint256)`. |
| 1924 | mstore(0x00, 0x20098014) |
| 1925 | mstore(0x20, p0) |
| 1926 | mstore(0x40, p1) |
| 1927 | mstore(0x60, p2) |
| 1928 | } |
| 1929 | _sendLogPayload(0x1c, 0x64); |
| 1930 | /// @solidity memory-safe-assembly |
| 1931 | assembly { |
| 1932 | mstore(0x00, m0) |
| 1933 | mstore(0x20, m1) |
| 1934 | mstore(0x40, m2) |
| 1935 | mstore(0x60, m3) |
| 1936 | } |
| 1937 | } |
| 1938 | |
| 1939 | function log(uint256 p0, bool p1, bytes32 p2) internal pure { |
| 1940 | bytes32 m0; |
| 1941 | bytes32 m1; |
| 1942 | bytes32 m2; |
| 1943 | bytes32 m3; |
| 1944 | bytes32 m4; |
| 1945 | bytes32 m5; |
| 1946 | /// @solidity memory-safe-assembly |
| 1947 | assembly { |
| 1948 | function writeString(pos, w) { |
| 1949 | let length := 0 |
| 1950 | for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } |
| 1951 | mstore(pos, length) |
| 1952 | let shift := sub(256, shl(3, length)) |
| 1953 | mstore(add(pos, 0x20), shl(shift, shr(shift, w))) |
| 1954 | } |
| 1955 | m0 := mload(0x00) |
| 1956 | m1 := mload(0x20) |
| 1957 | m2 := mload(0x40) |
| 1958 | m3 := mload(0x60) |
| 1959 | m4 := mload(0x80) |
| 1960 | m5 := mload(0xa0) |
| 1961 | // Selector of `log(uint256,bool,string)`. |
| 1962 | mstore(0x00, 0x85775021) |
| 1963 | mstore(0x20, p0) |
| 1964 | mstore(0x40, p1) |
| 1965 | mstore(0x60, 0x60) |
| 1966 | writeString(0x80, p2) |
| 1967 | } |
| 1968 | _sendLogPayload(0x1c, 0xa4); |
| 1969 | /// @solidity memory-safe-assembly |
| 1970 | assembly { |
| 1971 | mstore(0x00, m0) |
| 1972 | mstore(0x20, m1) |
| 1973 | mstore(0x40, m2) |
| 1974 | mstore(0x60, m3) |
| 1975 | mstore(0x80, m4) |
| 1976 | mstore(0xa0, m5) |
| 1977 | } |
| 1978 | } |
| 1979 | |
| 1980 | function log(uint256 p0, uint256 p1, address p2) internal pure { |
| 1981 | bytes32 m0; |
| 1982 | bytes32 m1; |
| 1983 | bytes32 m2; |
| 1984 | bytes32 m3; |
| 1985 | /// @solidity memory-safe-assembly |
| 1986 | assembly { |
| 1987 | m0 := mload(0x00) |
| 1988 | m1 := mload(0x20) |
| 1989 | m2 := mload(0x40) |
| 1990 | m3 := mload(0x60) |
| 1991 | // Selector of `log(uint256,uint256,address)`. |
| 1992 | mstore(0x00, 0x5c96b331) |
| 1993 | mstore(0x20, p0) |
| 1994 | mstore(0x40, p1) |
| 1995 | mstore(0x60, p2) |
| 1996 | } |
| 1997 | _sendLogPayload(0x1c, 0x64); |
| 1998 | /// @solidity memory-safe-assembly |
| 1999 | assembly { |
| 2000 | mstore(0x00, m0) |
| 2001 | mstore(0x20, m1) |
| 2002 | mstore(0x40, m2) |
| 2003 | mstore(0x60, m3) |
| 2004 | } |
| 2005 | } |
| 2006 | |
| 2007 | function log(uint256 p0, uint256 p1, bool p2) internal pure { |
| 2008 | bytes32 m0; |
| 2009 | bytes32 m1; |
| 2010 | bytes32 m2; |
| 2011 | bytes32 m3; |
| 2012 | /// @solidity memory-safe-assembly |
| 2013 | assembly { |
| 2014 | m0 := mload(0x00) |
| 2015 | m1 := mload(0x20) |
| 2016 | m2 := mload(0x40) |
| 2017 | m3 := mload(0x60) |
| 2018 | // Selector of `log(uint256,uint256,bool)`. |
| 2019 | mstore(0x00, 0x4766da72) |
| 2020 | mstore(0x20, p0) |
| 2021 | mstore(0x40, p1) |
| 2022 | mstore(0x60, p2) |
| 2023 | } |
| 2024 | _sendLogPayload(0x1c, 0x64); |
| 2025 | /// @solidity memory-safe-assembly |
| 2026 | assembly { |
| 2027 | mstore(0x00, m0) |
| 2028 | mstore(0x20, m1) |
| 2029 | mstore(0x40, m2) |
| 2030 | mstore(0x60, m3) |
| 2031 | } |
| 2032 | } |
| 2033 | |
| 2034 | function log(uint256 p0, uint256 p1, uint256 p2) internal pure { |
| 2035 | bytes32 m0; |
| 2036 | bytes32 m1; |
| 2037 | bytes32 m2; |
| 2038 | bytes32 m3; |
| 2039 | /// @solidity memory-safe-assembly |
| 2040 | assembly { |
| 2041 | m0 := mload(0x00) |
| 2042 | m1 := mload(0x20) |
| 2043 | m2 := mload(0x40) |
| 2044 | m3 := mload(0x60) |
| 2045 | // Selector of `log(uint256,uint256,uint256)`. |
| 2046 | mstore(0x00, 0xd1ed7a3c) |
| 2047 | mstore(0x20, p0) |
| 2048 | mstore(0x40, p1) |
| 2049 | mstore(0x60, p2) |
| 2050 | } |
| 2051 | _sendLogPayload(0x1c, 0x64); |
| 2052 | /// @solidity memory-safe-assembly |
| 2053 | assembly { |
| 2054 | mstore(0x00, m0) |
| 2055 | mstore(0x20, m1) |
| 2056 | mstore(0x40, m2) |
| 2057 | mstore(0x60, m3) |
| 2058 | } |
| 2059 | } |
| 2060 | |
| 2061 | function log(uint256 p0, uint256 p1, bytes32 p2) internal pure { |
| 2062 | bytes32 m0; |
| 2063 | bytes32 m1; |
| 2064 | bytes32 m2; |
| 2065 | bytes32 m3; |
| 2066 | bytes32 m4; |
| 2067 | bytes32 m5; |
| 2068 | /// @solidity memory-safe-assembly |
| 2069 | assembly { |
| 2070 | function writeString(pos, w) { |
| 2071 | let length := 0 |
| 2072 | for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } |
| 2073 | mstore(pos, length) |
| 2074 | let shift := sub(256, shl(3, length)) |
| 2075 | mstore(add(pos, 0x20), shl(shift, shr(shift, w))) |
| 2076 | } |
| 2077 | m0 := mload(0x00) |
| 2078 | m1 := mload(0x20) |
| 2079 | m2 := mload(0x40) |
| 2080 | m3 := mload(0x60) |
| 2081 | m4 := mload(0x80) |
| 2082 | m5 := mload(0xa0) |
| 2083 | // Selector of `log(uint256,uint256,string)`. |
| 2084 | mstore(0x00, 0x71d04af2) |
| 2085 | mstore(0x20, p0) |
| 2086 | mstore(0x40, p1) |
| 2087 | mstore(0x60, 0x60) |
| 2088 | writeString(0x80, p2) |
| 2089 | } |
| 2090 | _sendLogPayload(0x1c, 0xa4); |
| 2091 | /// @solidity memory-safe-assembly |
| 2092 | assembly { |
| 2093 | mstore(0x00, m0) |
| 2094 | mstore(0x20, m1) |
| 2095 | mstore(0x40, m2) |
| 2096 | mstore(0x60, m3) |
| 2097 | mstore(0x80, m4) |
| 2098 | mstore(0xa0, m5) |
| 2099 | } |
| 2100 | } |
| 2101 | |
| 2102 | function log(uint256 p0, bytes32 p1, address p2) internal pure { |
| 2103 | bytes32 m0; |
| 2104 | bytes32 m1; |
| 2105 | bytes32 m2; |
| 2106 | bytes32 m3; |
| 2107 | bytes32 m4; |
| 2108 | bytes32 m5; |
| 2109 | /// @solidity memory-safe-assembly |
| 2110 | assembly { |
| 2111 | function writeString(pos, w) { |
| 2112 | let length := 0 |
| 2113 | for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } |
| 2114 | mstore(pos, length) |
| 2115 | let shift := sub(256, shl(3, length)) |
| 2116 | mstore(add(pos, 0x20), shl(shift, shr(shift, w))) |
| 2117 | } |
| 2118 | m0 := mload(0x00) |
| 2119 | m1 := mload(0x20) |
| 2120 | m2 := mload(0x40) |
| 2121 | m3 := mload(0x60) |
| 2122 | m4 := mload(0x80) |
| 2123 | m5 := mload(0xa0) |
| 2124 | // Selector of `log(uint256,string,address)`. |
| 2125 | mstore(0x00, 0x7afac959) |
| 2126 | mstore(0x20, p0) |
| 2127 | mstore(0x40, 0x60) |
| 2128 | mstore(0x60, p2) |
| 2129 | writeString(0x80, p1) |
| 2130 | } |
| 2131 | _sendLogPayload(0x1c, 0xa4); |
| 2132 | /// @solidity memory-safe-assembly |
| 2133 | assembly { |
| 2134 | mstore(0x00, m0) |
| 2135 | mstore(0x20, m1) |
| 2136 | mstore(0x40, m2) |
| 2137 | mstore(0x60, m3) |
| 2138 | mstore(0x80, m4) |
| 2139 | mstore(0xa0, m5) |
| 2140 | } |
| 2141 | } |
| 2142 | |
| 2143 | function log(uint256 p0, bytes32 p1, bool p2) internal pure { |
| 2144 | bytes32 m0; |
| 2145 | bytes32 m1; |
| 2146 | bytes32 m2; |
| 2147 | bytes32 m3; |
| 2148 | bytes32 m4; |
| 2149 | bytes32 m5; |
| 2150 | /// @solidity memory-safe-assembly |
| 2151 | assembly { |
| 2152 | function writeString(pos, w) { |
| 2153 | let length := 0 |
| 2154 | for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } |
| 2155 | mstore(pos, length) |
| 2156 | let shift := sub(256, shl(3, length)) |
| 2157 | mstore(add(pos, 0x20), shl(shift, shr(shift, w))) |
| 2158 | } |
| 2159 | m0 := mload(0x00) |
| 2160 | m1 := mload(0x20) |
| 2161 | m2 := mload(0x40) |
| 2162 | m3 := mload(0x60) |
| 2163 | m4 := mload(0x80) |
| 2164 | m5 := mload(0xa0) |
| 2165 | // Selector of `log(uint256,string,bool)`. |
| 2166 | mstore(0x00, 0x4ceda75a) |
| 2167 | mstore(0x20, p0) |
| 2168 | mstore(0x40, 0x60) |
| 2169 | mstore(0x60, p2) |
| 2170 | writeString(0x80, p1) |
| 2171 | } |
| 2172 | _sendLogPayload(0x1c, 0xa4); |
| 2173 | /// @solidity memory-safe-assembly |
| 2174 | assembly { |
| 2175 | mstore(0x00, m0) |
| 2176 | mstore(0x20, m1) |
| 2177 | mstore(0x40, m2) |
| 2178 | mstore(0x60, m3) |
| 2179 | mstore(0x80, m4) |
| 2180 | mstore(0xa0, m5) |
| 2181 | } |
| 2182 | } |
| 2183 | |
| 2184 | function log(uint256 p0, bytes32 p1, uint256 p2) internal pure { |
| 2185 | bytes32 m0; |
| 2186 | bytes32 m1; |
| 2187 | bytes32 m2; |
| 2188 | bytes32 m3; |
| 2189 | bytes32 m4; |
| 2190 | bytes32 m5; |
| 2191 | /// @solidity memory-safe-assembly |
| 2192 | assembly { |
| 2193 | function writeString(pos, w) { |
| 2194 | let length := 0 |
| 2195 | for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } |
| 2196 | mstore(pos, length) |
| 2197 | let shift := sub(256, shl(3, length)) |
| 2198 | mstore(add(pos, 0x20), shl(shift, shr(shift, w))) |
| 2199 | } |
| 2200 | m0 := mload(0x00) |
| 2201 | m1 := mload(0x20) |
| 2202 | m2 := mload(0x40) |
| 2203 | m3 := mload(0x60) |
| 2204 | m4 := mload(0x80) |
| 2205 | m5 := mload(0xa0) |
| 2206 | // Selector of `log(uint256,string,uint256)`. |
| 2207 | mstore(0x00, 0x37aa7d4c) |
| 2208 | mstore(0x20, p0) |
| 2209 | mstore(0x40, 0x60) |
| 2210 | mstore(0x60, p2) |
| 2211 | writeString(0x80, p1) |
| 2212 | } |
| 2213 | _sendLogPayload(0x1c, 0xa4); |
| 2214 | /// @solidity memory-safe-assembly |
| 2215 | assembly { |
| 2216 | mstore(0x00, m0) |
| 2217 | mstore(0x20, m1) |
| 2218 | mstore(0x40, m2) |
| 2219 | mstore(0x60, m3) |
| 2220 | mstore(0x80, m4) |
| 2221 | mstore(0xa0, m5) |
| 2222 | } |
| 2223 | } |
| 2224 | |
| 2225 | function log(uint256 p0, bytes32 p1, bytes32 p2) internal pure { |
| 2226 | bytes32 m0; |
| 2227 | bytes32 m1; |
| 2228 | bytes32 m2; |
| 2229 | bytes32 m3; |
| 2230 | bytes32 m4; |
| 2231 | bytes32 m5; |
| 2232 | bytes32 m6; |
| 2233 | bytes32 m7; |
| 2234 | /// @solidity memory-safe-assembly |
| 2235 | assembly { |
| 2236 | function writeString(pos, w) { |
| 2237 | let length := 0 |
| 2238 | for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } |
| 2239 | mstore(pos, length) |
| 2240 | let shift := sub(256, shl(3, length)) |
| 2241 | mstore(add(pos, 0x20), shl(shift, shr(shift, w))) |
| 2242 | } |
| 2243 | m0 := mload(0x00) |
| 2244 | m1 := mload(0x20) |
| 2245 | m2 := mload(0x40) |
| 2246 | m3 := mload(0x60) |
| 2247 | m4 := mload(0x80) |
| 2248 | m5 := mload(0xa0) |
| 2249 | m6 := mload(0xc0) |
| 2250 | m7 := mload(0xe0) |
| 2251 | // Selector of `log(uint256,string,string)`. |
| 2252 | mstore(0x00, 0xb115611f) |
| 2253 | mstore(0x20, p0) |
| 2254 | mstore(0x40, 0x60) |
| 2255 | mstore(0x60, 0xa0) |
| 2256 | writeString(0x80, p1) |
| 2257 | writeString(0xc0, p2) |
| 2258 | } |
| 2259 | _sendLogPayload(0x1c, 0xe4); |
| 2260 | /// @solidity memory-safe-assembly |
| 2261 | assembly { |
| 2262 | mstore(0x00, m0) |
| 2263 | mstore(0x20, m1) |
| 2264 | mstore(0x40, m2) |
| 2265 | mstore(0x60, m3) |
| 2266 | mstore(0x80, m4) |
| 2267 | mstore(0xa0, m5) |
| 2268 | mstore(0xc0, m6) |
| 2269 | mstore(0xe0, m7) |
| 2270 | } |
| 2271 | } |
| 2272 | |
| 2273 | function log(bytes32 p0, address p1, address p2) internal pure { |
| 2274 | bytes32 m0; |
| 2275 | bytes32 m1; |
| 2276 | bytes32 m2; |
| 2277 | bytes32 m3; |
| 2278 | bytes32 m4; |
| 2279 | bytes32 m5; |
| 2280 | /// @solidity memory-safe-assembly |
| 2281 | assembly { |
| 2282 | function writeString(pos, w) { |
| 2283 | let length := 0 |
| 2284 | for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } |
| 2285 | mstore(pos, length) |
| 2286 | let shift := sub(256, shl(3, length)) |
| 2287 | mstore(add(pos, 0x20), shl(shift, shr(shift, w))) |
| 2288 | } |
| 2289 | m0 := mload(0x00) |
| 2290 | m1 := mload(0x20) |
| 2291 | m2 := mload(0x40) |
| 2292 | m3 := mload(0x60) |
| 2293 | m4 := mload(0x80) |
| 2294 | m5 := mload(0xa0) |
| 2295 | // Selector of `log(string,address,address)`. |
| 2296 | mstore(0x00, 0xfcec75e0) |
| 2297 | mstore(0x20, 0x60) |
| 2298 | mstore(0x40, p1) |
| 2299 | mstore(0x60, p2) |
| 2300 | writeString(0x80, p0) |
| 2301 | } |
| 2302 | _sendLogPayload(0x1c, 0xa4); |
| 2303 | /// @solidity memory-safe-assembly |
| 2304 | assembly { |
| 2305 | mstore(0x00, m0) |
| 2306 | mstore(0x20, m1) |
| 2307 | mstore(0x40, m2) |
| 2308 | mstore(0x60, m3) |
| 2309 | mstore(0x80, m4) |
| 2310 | mstore(0xa0, m5) |
| 2311 | } |
| 2312 | } |
| 2313 | |
| 2314 | function log(bytes32 p0, address p1, bool p2) internal pure { |
| 2315 | bytes32 m0; |
| 2316 | bytes32 m1; |
| 2317 | bytes32 m2; |
| 2318 | bytes32 m3; |
| 2319 | bytes32 m4; |
| 2320 | bytes32 m5; |
| 2321 | /// @solidity memory-safe-assembly |
| 2322 | assembly { |
| 2323 | function writeString(pos, w) { |
| 2324 | let length := 0 |
| 2325 | for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } |
| 2326 | mstore(pos, length) |
| 2327 | let shift := sub(256, shl(3, length)) |
| 2328 | mstore(add(pos, 0x20), shl(shift, shr(shift, w))) |
| 2329 | } |
| 2330 | m0 := mload(0x00) |
| 2331 | m1 := mload(0x20) |
| 2332 | m2 := mload(0x40) |
| 2333 | m3 := mload(0x60) |
| 2334 | m4 := mload(0x80) |
| 2335 | m5 := mload(0xa0) |
| 2336 | // Selector of `log(string,address,bool)`. |
| 2337 | mstore(0x00, 0xc91d5ed4) |
| 2338 | mstore(0x20, 0x60) |
| 2339 | mstore(0x40, p1) |
| 2340 | mstore(0x60, p2) |
| 2341 | writeString(0x80, p0) |
| 2342 | } |
| 2343 | _sendLogPayload(0x1c, 0xa4); |
| 2344 | /// @solidity memory-safe-assembly |
| 2345 | assembly { |
| 2346 | mstore(0x00, m0) |
| 2347 | mstore(0x20, m1) |
| 2348 | mstore(0x40, m2) |
| 2349 | mstore(0x60, m3) |
| 2350 | mstore(0x80, m4) |
| 2351 | mstore(0xa0, m5) |
| 2352 | } |
| 2353 | } |
| 2354 | |
| 2355 | function log(bytes32 p0, address p1, uint256 p2) internal pure { |
| 2356 | bytes32 m0; |
| 2357 | bytes32 m1; |
| 2358 | bytes32 m2; |
| 2359 | bytes32 m3; |
| 2360 | bytes32 m4; |
| 2361 | bytes32 m5; |
| 2362 | /// @solidity memory-safe-assembly |
| 2363 | assembly { |
| 2364 | function writeString(pos, w) { |
| 2365 | let length := 0 |
| 2366 | for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } |
| 2367 | mstore(pos, length) |
| 2368 | let shift := sub(256, shl(3, length)) |
| 2369 | mstore(add(pos, 0x20), shl(shift, shr(shift, w))) |
| 2370 | } |
| 2371 | m0 := mload(0x00) |
| 2372 | m1 := mload(0x20) |
| 2373 | m2 := mload(0x40) |
| 2374 | m3 := mload(0x60) |
| 2375 | m4 := mload(0x80) |
| 2376 | m5 := mload(0xa0) |
| 2377 | // Selector of `log(string,address,uint256)`. |
| 2378 | mstore(0x00, 0x0d26b925) |
| 2379 | mstore(0x20, 0x60) |
| 2380 | mstore(0x40, p1) |
| 2381 | mstore(0x60, p2) |
| 2382 | writeString(0x80, p0) |
| 2383 | } |
| 2384 | _sendLogPayload(0x1c, 0xa4); |
| 2385 | /// @solidity memory-safe-assembly |
| 2386 | assembly { |
| 2387 | mstore(0x00, m0) |
| 2388 | mstore(0x20, m1) |
| 2389 | mstore(0x40, m2) |
| 2390 | mstore(0x60, m3) |
| 2391 | mstore(0x80, m4) |
| 2392 | mstore(0xa0, m5) |
| 2393 | } |
| 2394 | } |
| 2395 | |
| 2396 | function log(bytes32 p0, address p1, bytes32 p2) internal pure { |
| 2397 | bytes32 m0; |
| 2398 | bytes32 m1; |
| 2399 | bytes32 m2; |
| 2400 | bytes32 m3; |
| 2401 | bytes32 m4; |
| 2402 | bytes32 m5; |
| 2403 | bytes32 m6; |
| 2404 | bytes32 m7; |
| 2405 | /// @solidity memory-safe-assembly |
| 2406 | assembly { |
| 2407 | function writeString(pos, w) { |
| 2408 | let length := 0 |
| 2409 | for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } |
| 2410 | mstore(pos, length) |
| 2411 | let shift := sub(256, shl(3, length)) |
| 2412 | mstore(add(pos, 0x20), shl(shift, shr(shift, w))) |
| 2413 | } |
| 2414 | m0 := mload(0x00) |
| 2415 | m1 := mload(0x20) |
| 2416 | m2 := mload(0x40) |
| 2417 | m3 := mload(0x60) |
| 2418 | m4 := mload(0x80) |
| 2419 | m5 := mload(0xa0) |
| 2420 | m6 := mload(0xc0) |
| 2421 | m7 := mload(0xe0) |
| 2422 | // Selector of `log(string,address,string)`. |
| 2423 | mstore(0x00, 0xe0e9ad4f) |
| 2424 | mstore(0x20, 0x60) |
| 2425 | mstore(0x40, p1) |
| 2426 | mstore(0x60, 0xa0) |
| 2427 | writeString(0x80, p0) |
| 2428 | writeString(0xc0, p2) |
| 2429 | } |
| 2430 | _sendLogPayload(0x1c, 0xe4); |
| 2431 | /// @solidity memory-safe-assembly |
| 2432 | assembly { |
| 2433 | mstore(0x00, m0) |
| 2434 | mstore(0x20, m1) |
| 2435 | mstore(0x40, m2) |
| 2436 | mstore(0x60, m3) |
| 2437 | mstore(0x80, m4) |
| 2438 | mstore(0xa0, m5) |
| 2439 | mstore(0xc0, m6) |
| 2440 | mstore(0xe0, m7) |
| 2441 | } |
| 2442 | } |
| 2443 | |
| 2444 | function log(bytes32 p0, bool p1, address p2) internal pure { |
| 2445 | bytes32 m0; |
| 2446 | bytes32 m1; |
| 2447 | bytes32 m2; |
| 2448 | bytes32 m3; |
| 2449 | bytes32 m4; |
| 2450 | bytes32 m5; |
| 2451 | /// @solidity memory-safe-assembly |
| 2452 | assembly { |
| 2453 | function writeString(pos, w) { |
| 2454 | let length := 0 |
| 2455 | for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } |
| 2456 | mstore(pos, length) |
| 2457 | let shift := sub(256, shl(3, length)) |
| 2458 | mstore(add(pos, 0x20), shl(shift, shr(shift, w))) |
| 2459 | } |
| 2460 | m0 := mload(0x00) |
| 2461 | m1 := mload(0x20) |
| 2462 | m2 := mload(0x40) |
| 2463 | m3 := mload(0x60) |
| 2464 | m4 := mload(0x80) |
| 2465 | m5 := mload(0xa0) |
| 2466 | // Selector of `log(string,bool,address)`. |
| 2467 | mstore(0x00, 0x932bbb38) |
| 2468 | mstore(0x20, 0x60) |
| 2469 | mstore(0x40, p1) |
| 2470 | mstore(0x60, p2) |
| 2471 | writeString(0x80, p0) |
| 2472 | } |
| 2473 | _sendLogPayload(0x1c, 0xa4); |
| 2474 | /// @solidity memory-safe-assembly |
| 2475 | assembly { |
| 2476 | mstore(0x00, m0) |
| 2477 | mstore(0x20, m1) |
| 2478 | mstore(0x40, m2) |
| 2479 | mstore(0x60, m3) |
| 2480 | mstore(0x80, m4) |
| 2481 | mstore(0xa0, m5) |
| 2482 | } |
| 2483 | } |
| 2484 | |
| 2485 | function log(bytes32 p0, bool p1, bool p2) internal pure { |
| 2486 | bytes32 m0; |
| 2487 | bytes32 m1; |
| 2488 | bytes32 m2; |
| 2489 | bytes32 m3; |
| 2490 | bytes32 m4; |
| 2491 | bytes32 m5; |
| 2492 | /// @solidity memory-safe-assembly |
| 2493 | assembly { |
| 2494 | function writeString(pos, w) { |
| 2495 | let length := 0 |
| 2496 | for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } |
| 2497 | mstore(pos, length) |
| 2498 | let shift := sub(256, shl(3, length)) |
| 2499 | mstore(add(pos, 0x20), shl(shift, shr(shift, w))) |
| 2500 | } |
| 2501 | m0 := mload(0x00) |
| 2502 | m1 := mload(0x20) |
| 2503 | m2 := mload(0x40) |
| 2504 | m3 := mload(0x60) |
| 2505 | m4 := mload(0x80) |
| 2506 | m5 := mload(0xa0) |
| 2507 | // Selector of `log(string,bool,bool)`. |
| 2508 | mstore(0x00, 0x850b7ad6) |
| 2509 | mstore(0x20, 0x60) |
| 2510 | mstore(0x40, p1) |
| 2511 | mstore(0x60, p2) |
| 2512 | writeString(0x80, p0) |
| 2513 | } |
| 2514 | _sendLogPayload(0x1c, 0xa4); |
| 2515 | /// @solidity memory-safe-assembly |
| 2516 | assembly { |
| 2517 | mstore(0x00, m0) |
| 2518 | mstore(0x20, m1) |
| 2519 | mstore(0x40, m2) |
| 2520 | mstore(0x60, m3) |
| 2521 | mstore(0x80, m4) |
| 2522 | mstore(0xa0, m5) |
| 2523 | } |
| 2524 | } |
| 2525 | |
| 2526 | function log(bytes32 p0, bool p1, uint256 p2) internal pure { |
| 2527 | bytes32 m0; |
| 2528 | bytes32 m1; |
| 2529 | bytes32 m2; |
| 2530 | bytes32 m3; |
| 2531 | bytes32 m4; |
| 2532 | bytes32 m5; |
| 2533 | /// @solidity memory-safe-assembly |
| 2534 | assembly { |
| 2535 | function writeString(pos, w) { |
| 2536 | let length := 0 |
| 2537 | for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } |
| 2538 | mstore(pos, length) |
| 2539 | let shift := sub(256, shl(3, length)) |
| 2540 | mstore(add(pos, 0x20), shl(shift, shr(shift, w))) |
| 2541 | } |
| 2542 | m0 := mload(0x00) |
| 2543 | m1 := mload(0x20) |
| 2544 | m2 := mload(0x40) |
| 2545 | m3 := mload(0x60) |
| 2546 | m4 := mload(0x80) |
| 2547 | m5 := mload(0xa0) |
| 2548 | // Selector of `log(string,bool,uint256)`. |
| 2549 | mstore(0x00, 0xc95958d6) |
| 2550 | mstore(0x20, 0x60) |
| 2551 | mstore(0x40, p1) |
| 2552 | mstore(0x60, p2) |
| 2553 | writeString(0x80, p0) |
| 2554 | } |
| 2555 | _sendLogPayload(0x1c, 0xa4); |
| 2556 | /// @solidity memory-safe-assembly |
| 2557 | assembly { |
| 2558 | mstore(0x00, m0) |
| 2559 | mstore(0x20, m1) |
| 2560 | mstore(0x40, m2) |
| 2561 | mstore(0x60, m3) |
| 2562 | mstore(0x80, m4) |
| 2563 | mstore(0xa0, m5) |
| 2564 | } |
| 2565 | } |
| 2566 | |
| 2567 | function log(bytes32 p0, bool p1, bytes32 p2) internal pure { |
| 2568 | bytes32 m0; |
| 2569 | bytes32 m1; |
| 2570 | bytes32 m2; |
| 2571 | bytes32 m3; |
| 2572 | bytes32 m4; |
| 2573 | bytes32 m5; |
| 2574 | bytes32 m6; |
| 2575 | bytes32 m7; |
| 2576 | /// @solidity memory-safe-assembly |
| 2577 | assembly { |
| 2578 | function writeString(pos, w) { |
| 2579 | let length := 0 |
| 2580 | for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } |
| 2581 | mstore(pos, length) |
| 2582 | let shift := sub(256, shl(3, length)) |
| 2583 | mstore(add(pos, 0x20), shl(shift, shr(shift, w))) |
| 2584 | } |
| 2585 | m0 := mload(0x00) |
| 2586 | m1 := mload(0x20) |
| 2587 | m2 := mload(0x40) |
| 2588 | m3 := mload(0x60) |
| 2589 | m4 := mload(0x80) |
| 2590 | m5 := mload(0xa0) |
| 2591 | m6 := mload(0xc0) |
| 2592 | m7 := mload(0xe0) |
| 2593 | // Selector of `log(string,bool,string)`. |
| 2594 | mstore(0x00, 0xe298f47d) |
| 2595 | mstore(0x20, 0x60) |
| 2596 | mstore(0x40, p1) |
| 2597 | mstore(0x60, 0xa0) |
| 2598 | writeString(0x80, p0) |
| 2599 | writeString(0xc0, p2) |
| 2600 | } |
| 2601 | _sendLogPayload(0x1c, 0xe4); |
| 2602 | /// @solidity memory-safe-assembly |
| 2603 | assembly { |
| 2604 | mstore(0x00, m0) |
| 2605 | mstore(0x20, m1) |
| 2606 | mstore(0x40, m2) |
| 2607 | mstore(0x60, m3) |
| 2608 | mstore(0x80, m4) |
| 2609 | mstore(0xa0, m5) |
| 2610 | mstore(0xc0, m6) |
| 2611 | mstore(0xe0, m7) |
| 2612 | } |
| 2613 | } |
| 2614 | |
| 2615 | function log(bytes32 p0, uint256 p1, address p2) internal pure { |
| 2616 | bytes32 m0; |
| 2617 | bytes32 m1; |
| 2618 | bytes32 m2; |
| 2619 | bytes32 m3; |
| 2620 | bytes32 m4; |
| 2621 | bytes32 m5; |
| 2622 | /// @solidity memory-safe-assembly |
| 2623 | assembly { |
| 2624 | function writeString(pos, w) { |
| 2625 | let length := 0 |
| 2626 | for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } |
| 2627 | mstore(pos, length) |
| 2628 | let shift := sub(256, shl(3, length)) |
| 2629 | mstore(add(pos, 0x20), shl(shift, shr(shift, w))) |
| 2630 | } |
| 2631 | m0 := mload(0x00) |
| 2632 | m1 := mload(0x20) |
| 2633 | m2 := mload(0x40) |
| 2634 | m3 := mload(0x60) |
| 2635 | m4 := mload(0x80) |
| 2636 | m5 := mload(0xa0) |
| 2637 | // Selector of `log(string,uint256,address)`. |
| 2638 | mstore(0x00, 0x1c7ec448) |
| 2639 | mstore(0x20, 0x60) |
| 2640 | mstore(0x40, p1) |
| 2641 | mstore(0x60, p2) |
| 2642 | writeString(0x80, p0) |
| 2643 | } |
| 2644 | _sendLogPayload(0x1c, 0xa4); |
| 2645 | /// @solidity memory-safe-assembly |
| 2646 | assembly { |
| 2647 | mstore(0x00, m0) |
| 2648 | mstore(0x20, m1) |
| 2649 | mstore(0x40, m2) |
| 2650 | mstore(0x60, m3) |
| 2651 | mstore(0x80, m4) |
| 2652 | mstore(0xa0, m5) |
| 2653 | } |
| 2654 | } |
| 2655 | |
| 2656 | function log(bytes32 p0, uint256 p1, bool p2) internal pure { |
| 2657 | bytes32 m0; |
| 2658 | bytes32 m1; |
| 2659 | bytes32 m2; |
| 2660 | bytes32 m3; |
| 2661 | bytes32 m4; |
| 2662 | bytes32 m5; |
| 2663 | /// @solidity memory-safe-assembly |
| 2664 | assembly { |
| 2665 | function writeString(pos, w) { |
| 2666 | let length := 0 |
| 2667 | for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } |
| 2668 | mstore(pos, length) |
| 2669 | let shift := sub(256, shl(3, length)) |
| 2670 | mstore(add(pos, 0x20), shl(shift, shr(shift, w))) |
| 2671 | } |
| 2672 | m0 := mload(0x00) |
| 2673 | m1 := mload(0x20) |
| 2674 | m2 := mload(0x40) |
| 2675 | m3 := mload(0x60) |
| 2676 | m4 := mload(0x80) |
| 2677 | m5 := mload(0xa0) |
| 2678 | // Selector of `log(string,uint256,bool)`. |
| 2679 | mstore(0x00, 0xca7733b1) |
| 2680 | mstore(0x20, 0x60) |
| 2681 | mstore(0x40, p1) |
| 2682 | mstore(0x60, p2) |
| 2683 | writeString(0x80, p0) |
| 2684 | } |
| 2685 | _sendLogPayload(0x1c, 0xa4); |
| 2686 | /// @solidity memory-safe-assembly |
| 2687 | assembly { |
| 2688 | mstore(0x00, m0) |
| 2689 | mstore(0x20, m1) |
| 2690 | mstore(0x40, m2) |
| 2691 | mstore(0x60, m3) |
| 2692 | mstore(0x80, m4) |
| 2693 | mstore(0xa0, m5) |
| 2694 | } |
| 2695 | } |
| 2696 | |
| 2697 | function log(bytes32 p0, uint256 p1, uint256 p2) internal pure { |
| 2698 | bytes32 m0; |
| 2699 | bytes32 m1; |
| 2700 | bytes32 m2; |
| 2701 | bytes32 m3; |
| 2702 | bytes32 m4; |
| 2703 | bytes32 m5; |
| 2704 | /// @solidity memory-safe-assembly |
| 2705 | assembly { |
| 2706 | function writeString(pos, w) { |
| 2707 | let length := 0 |
| 2708 | for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } |
| 2709 | mstore(pos, length) |
| 2710 | let shift := sub(256, shl(3, length)) |
| 2711 | mstore(add(pos, 0x20), shl(shift, shr(shift, w))) |
| 2712 | } |
| 2713 | m0 := mload(0x00) |
| 2714 | m1 := mload(0x20) |
| 2715 | m2 := mload(0x40) |
| 2716 | m3 := mload(0x60) |
| 2717 | m4 := mload(0x80) |
| 2718 | m5 := mload(0xa0) |
| 2719 | // Selector of `log(string,uint256,uint256)`. |
| 2720 | mstore(0x00, 0xca47c4eb) |
| 2721 | mstore(0x20, 0x60) |
| 2722 | mstore(0x40, p1) |
| 2723 | mstore(0x60, p2) |
| 2724 | writeString(0x80, p0) |
| 2725 | } |
| 2726 | _sendLogPayload(0x1c, 0xa4); |
| 2727 | /// @solidity memory-safe-assembly |
| 2728 | assembly { |
| 2729 | mstore(0x00, m0) |
| 2730 | mstore(0x20, m1) |
| 2731 | mstore(0x40, m2) |
| 2732 | mstore(0x60, m3) |
| 2733 | mstore(0x80, m4) |
| 2734 | mstore(0xa0, m5) |
| 2735 | } |
| 2736 | } |
| 2737 | |
| 2738 | function log(bytes32 p0, uint256 p1, bytes32 p2) internal pure { |
| 2739 | bytes32 m0; |
| 2740 | bytes32 m1; |
| 2741 | bytes32 m2; |
| 2742 | bytes32 m3; |
| 2743 | bytes32 m4; |
| 2744 | bytes32 m5; |
| 2745 | bytes32 m6; |
| 2746 | bytes32 m7; |
| 2747 | /// @solidity memory-safe-assembly |
| 2748 | assembly { |
| 2749 | function writeString(pos, w) { |
| 2750 | let length := 0 |
| 2751 | for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } |
| 2752 | mstore(pos, length) |
| 2753 | let shift := sub(256, shl(3, length)) |
| 2754 | mstore(add(pos, 0x20), shl(shift, shr(shift, w))) |
| 2755 | } |
| 2756 | m0 := mload(0x00) |
| 2757 | m1 := mload(0x20) |
| 2758 | m2 := mload(0x40) |
| 2759 | m3 := mload(0x60) |
| 2760 | m4 := mload(0x80) |
| 2761 | m5 := mload(0xa0) |
| 2762 | m6 := mload(0xc0) |
| 2763 | m7 := mload(0xe0) |
| 2764 | // Selector of `log(string,uint256,string)`. |
| 2765 | mstore(0x00, 0x5970e089) |
| 2766 | mstore(0x20, 0x60) |
| 2767 | mstore(0x40, p1) |
| 2768 | mstore(0x60, 0xa0) |
| 2769 | writeString(0x80, p0) |
| 2770 | writeString(0xc0, p2) |
| 2771 | } |
| 2772 | _sendLogPayload(0x1c, 0xe4); |
| 2773 | /// @solidity memory-safe-assembly |
| 2774 | assembly { |
| 2775 | mstore(0x00, m0) |
| 2776 | mstore(0x20, m1) |
| 2777 | mstore(0x40, m2) |
| 2778 | mstore(0x60, m3) |
| 2779 | mstore(0x80, m4) |
| 2780 | mstore(0xa0, m5) |
| 2781 | mstore(0xc0, m6) |
| 2782 | mstore(0xe0, m7) |
| 2783 | } |
| 2784 | } |
| 2785 | |
| 2786 | function log(bytes32 p0, bytes32 p1, address p2) internal pure { |
| 2787 | bytes32 m0; |
| 2788 | bytes32 m1; |
| 2789 | bytes32 m2; |
| 2790 | bytes32 m3; |
| 2791 | bytes32 m4; |
| 2792 | bytes32 m5; |
| 2793 | bytes32 m6; |
| 2794 | bytes32 m7; |
| 2795 | /// @solidity memory-safe-assembly |
| 2796 | assembly { |
| 2797 | function writeString(pos, w) { |
| 2798 | let length := 0 |
| 2799 | for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } |
| 2800 | mstore(pos, length) |
| 2801 | let shift := sub(256, shl(3, length)) |
| 2802 | mstore(add(pos, 0x20), shl(shift, shr(shift, w))) |
| 2803 | } |
| 2804 | m0 := mload(0x00) |
| 2805 | m1 := mload(0x20) |
| 2806 | m2 := mload(0x40) |
| 2807 | m3 := mload(0x60) |
| 2808 | m4 := mload(0x80) |
| 2809 | m5 := mload(0xa0) |
| 2810 | m6 := mload(0xc0) |
| 2811 | m7 := mload(0xe0) |
| 2812 | // Selector of `log(string,string,address)`. |
| 2813 | mstore(0x00, 0x95ed0195) |
| 2814 | mstore(0x20, 0x60) |
| 2815 | mstore(0x40, 0xa0) |
| 2816 | mstore(0x60, p2) |
| 2817 | writeString(0x80, p0) |
| 2818 | writeString(0xc0, p1) |
| 2819 | } |
| 2820 | _sendLogPayload(0x1c, 0xe4); |
| 2821 | /// @solidity memory-safe-assembly |
| 2822 | assembly { |
| 2823 | mstore(0x00, m0) |
| 2824 | mstore(0x20, m1) |
| 2825 | mstore(0x40, m2) |
| 2826 | mstore(0x60, m3) |
| 2827 | mstore(0x80, m4) |
| 2828 | mstore(0xa0, m5) |
| 2829 | mstore(0xc0, m6) |
| 2830 | mstore(0xe0, m7) |
| 2831 | } |
| 2832 | } |
| 2833 | |
| 2834 | function log(bytes32 p0, bytes32 p1, bool p2) internal pure { |
| 2835 | bytes32 m0; |
| 2836 | bytes32 m1; |
| 2837 | bytes32 m2; |
| 2838 | bytes32 m3; |
| 2839 | bytes32 m4; |
| 2840 | bytes32 m5; |
| 2841 | bytes32 m6; |
| 2842 | bytes32 m7; |
| 2843 | /// @solidity memory-safe-assembly |
| 2844 | assembly { |
| 2845 | function writeString(pos, w) { |
| 2846 | let length := 0 |
| 2847 | for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } |
| 2848 | mstore(pos, length) |
| 2849 | let shift := sub(256, shl(3, length)) |
| 2850 | mstore(add(pos, 0x20), shl(shift, shr(shift, w))) |
| 2851 | } |
| 2852 | m0 := mload(0x00) |
| 2853 | m1 := mload(0x20) |
| 2854 | m2 := mload(0x40) |
| 2855 | m3 := mload(0x60) |
| 2856 | m4 := mload(0x80) |
| 2857 | m5 := mload(0xa0) |
| 2858 | m6 := mload(0xc0) |
| 2859 | m7 := mload(0xe0) |
| 2860 | // Selector of `log(string,string,bool)`. |
| 2861 | mstore(0x00, 0xb0e0f9b5) |
| 2862 | mstore(0x20, 0x60) |
| 2863 | mstore(0x40, 0xa0) |
| 2864 | mstore(0x60, p2) |
| 2865 | writeString(0x80, p0) |
| 2866 | writeString(0xc0, p1) |
| 2867 | } |
| 2868 | _sendLogPayload(0x1c, 0xe4); |
| 2869 | /// @solidity memory-safe-assembly |
| 2870 | assembly { |
| 2871 | mstore(0x00, m0) |
| 2872 | mstore(0x20, m1) |
| 2873 | mstore(0x40, m2) |
| 2874 | mstore(0x60, m3) |
| 2875 | mstore(0x80, m4) |
| 2876 | mstore(0xa0, m5) |
| 2877 | mstore(0xc0, m6) |
| 2878 | mstore(0xe0, m7) |
| 2879 | } |
| 2880 | } |
| 2881 | |
| 2882 | function log(bytes32 p0, bytes32 p1, uint256 p2) internal pure { |
| 2883 | bytes32 m0; |
| 2884 | bytes32 m1; |
| 2885 | bytes32 m2; |
| 2886 | bytes32 m3; |
| 2887 | bytes32 m4; |
| 2888 | bytes32 m5; |
| 2889 | bytes32 m6; |
| 2890 | bytes32 m7; |
| 2891 | /// @solidity memory-safe-assembly |
| 2892 | assembly { |
| 2893 | function writeString(pos, w) { |
| 2894 | let length := 0 |
| 2895 | for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } |
| 2896 | mstore(pos, length) |
| 2897 | let shift := sub(256, shl(3, length)) |
| 2898 | mstore(add(pos, 0x20), shl(shift, shr(shift, w))) |
| 2899 | } |
| 2900 | m0 := mload(0x00) |
| 2901 | m1 := mload(0x20) |
| 2902 | m2 := mload(0x40) |
| 2903 | m3 := mload(0x60) |
| 2904 | m4 := mload(0x80) |
| 2905 | m5 := mload(0xa0) |
| 2906 | m6 := mload(0xc0) |
| 2907 | m7 := mload(0xe0) |
| 2908 | // Selector of `log(string,string,uint256)`. |
| 2909 | mstore(0x00, 0x5821efa1) |
| 2910 | mstore(0x20, 0x60) |
| 2911 | mstore(0x40, 0xa0) |
| 2912 | mstore(0x60, p2) |
| 2913 | writeString(0x80, p0) |
| 2914 | writeString(0xc0, p1) |
| 2915 | } |
| 2916 | _sendLogPayload(0x1c, 0xe4); |
| 2917 | /// @solidity memory-safe-assembly |
| 2918 | assembly { |
| 2919 | mstore(0x00, m0) |
| 2920 | mstore(0x20, m1) |
| 2921 | mstore(0x40, m2) |
| 2922 | mstore(0x60, m3) |
| 2923 | mstore(0x80, m4) |
| 2924 | mstore(0xa0, m5) |
| 2925 | mstore(0xc0, m6) |
| 2926 | mstore(0xe0, m7) |
| 2927 | } |
| 2928 | } |
| 2929 | |
| 2930 | function log(bytes32 p0, bytes32 p1, bytes32 p2) internal pure { |
| 2931 | bytes32 m0; |
| 2932 | bytes32 m1; |
| 2933 | bytes32 m2; |
| 2934 | bytes32 m3; |
| 2935 | bytes32 m4; |
| 2936 | bytes32 m5; |
| 2937 | bytes32 m6; |
| 2938 | bytes32 m7; |
| 2939 | bytes32 m8; |
| 2940 | bytes32 m9; |
| 2941 | /// @solidity memory-safe-assembly |
| 2942 | assembly { |
| 2943 | function writeString(pos, w) { |
| 2944 | let length := 0 |
| 2945 | for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } |
| 2946 | mstore(pos, length) |
| 2947 | let shift := sub(256, shl(3, length)) |
| 2948 | mstore(add(pos, 0x20), shl(shift, shr(shift, w))) |
| 2949 | } |
| 2950 | m0 := mload(0x00) |
| 2951 | m1 := mload(0x20) |
| 2952 | m2 := mload(0x40) |
| 2953 | m3 := mload(0x60) |
| 2954 | m4 := mload(0x80) |
| 2955 | m5 := mload(0xa0) |
| 2956 | m6 := mload(0xc0) |
| 2957 | m7 := mload(0xe0) |
| 2958 | m8 := mload(0x100) |
| 2959 | m9 := mload(0x120) |
| 2960 | // Selector of `log(string,string,string)`. |
| 2961 | mstore(0x00, 0x2ced7cef) |
| 2962 | mstore(0x20, 0x60) |
| 2963 | mstore(0x40, 0xa0) |
| 2964 | mstore(0x60, 0xe0) |
| 2965 | writeString(0x80, p0) |
| 2966 | writeString(0xc0, p1) |
| 2967 | writeString(0x100, p2) |
| 2968 | } |
| 2969 | _sendLogPayload(0x1c, 0x124); |
| 2970 | /// @solidity memory-safe-assembly |
| 2971 | assembly { |
| 2972 | mstore(0x00, m0) |
| 2973 | mstore(0x20, m1) |
| 2974 | mstore(0x40, m2) |
| 2975 | mstore(0x60, m3) |
| 2976 | mstore(0x80, m4) |
| 2977 | mstore(0xa0, m5) |
| 2978 | mstore(0xc0, m6) |
| 2979 | mstore(0xe0, m7) |
| 2980 | mstore(0x100, m8) |
| 2981 | mstore(0x120, m9) |
| 2982 | } |
| 2983 | } |
| 2984 | |
| 2985 | function log(address p0, address p1, address p2, address p3) internal pure { |
| 2986 | bytes32 m0; |
| 2987 | bytes32 m1; |
| 2988 | bytes32 m2; |
| 2989 | bytes32 m3; |
| 2990 | bytes32 m4; |
| 2991 | /// @solidity memory-safe-assembly |
| 2992 | assembly { |
| 2993 | m0 := mload(0x00) |
| 2994 | m1 := mload(0x20) |
| 2995 | m2 := mload(0x40) |
| 2996 | m3 := mload(0x60) |
| 2997 | m4 := mload(0x80) |
| 2998 | // Selector of `log(address,address,address,address)`. |
| 2999 | mstore(0x00, 0x665bf134) |
| 3000 | mstore(0x20, p0) |
| 3001 | mstore(0x40, p1) |
| 3002 | mstore(0x60, p2) |
| 3003 | mstore(0x80, p3) |
| 3004 | } |
| 3005 | _sendLogPayload(0x1c, 0x84); |
| 3006 | /// @solidity memory-safe-assembly |
| 3007 | assembly { |
| 3008 | mstore(0x00, m0) |
| 3009 | mstore(0x20, m1) |
| 3010 | mstore(0x40, m2) |
| 3011 | mstore(0x60, m3) |
| 3012 | mstore(0x80, m4) |
| 3013 | } |
| 3014 | } |
| 3015 | |
| 3016 | function log(address p0, address p1, address p2, bool p3) internal pure { |
| 3017 | bytes32 m0; |
| 3018 | bytes32 m1; |
| 3019 | bytes32 m2; |
| 3020 | bytes32 m3; |
| 3021 | bytes32 m4; |
| 3022 | /// @solidity memory-safe-assembly |
| 3023 | assembly { |
| 3024 | m0 := mload(0x00) |
| 3025 | m1 := mload(0x20) |
| 3026 | m2 := mload(0x40) |
| 3027 | m3 := mload(0x60) |
| 3028 | m4 := mload(0x80) |
| 3029 | // Selector of `log(address,address,address,bool)`. |
| 3030 | mstore(0x00, 0x0e378994) |
| 3031 | mstore(0x20, p0) |
| 3032 | mstore(0x40, p1) |
| 3033 | mstore(0x60, p2) |
| 3034 | mstore(0x80, p3) |
| 3035 | } |
| 3036 | _sendLogPayload(0x1c, 0x84); |
| 3037 | /// @solidity memory-safe-assembly |
| 3038 | assembly { |
| 3039 | mstore(0x00, m0) |
| 3040 | mstore(0x20, m1) |
| 3041 | mstore(0x40, m2) |
| 3042 | mstore(0x60, m3) |
| 3043 | mstore(0x80, m4) |
| 3044 | } |
| 3045 | } |
| 3046 | |
| 3047 | function log(address p0, address p1, address p2, uint256 p3) internal pure { |
| 3048 | bytes32 m0; |
| 3049 | bytes32 m1; |
| 3050 | bytes32 m2; |
| 3051 | bytes32 m3; |
| 3052 | bytes32 m4; |
| 3053 | /// @solidity memory-safe-assembly |
| 3054 | assembly { |
| 3055 | m0 := mload(0x00) |
| 3056 | m1 := mload(0x20) |
| 3057 | m2 := mload(0x40) |
| 3058 | m3 := mload(0x60) |
| 3059 | m4 := mload(0x80) |
| 3060 | // Selector of `log(address,address,address,uint256)`. |
| 3061 | mstore(0x00, 0x94250d77) |
| 3062 | mstore(0x20, p0) |
| 3063 | mstore(0x40, p1) |
| 3064 | mstore(0x60, p2) |
| 3065 | mstore(0x80, p3) |
| 3066 | } |
| 3067 | _sendLogPayload(0x1c, 0x84); |
| 3068 | /// @solidity memory-safe-assembly |
| 3069 | assembly { |
| 3070 | mstore(0x00, m0) |
| 3071 | mstore(0x20, m1) |
| 3072 | mstore(0x40, m2) |
| 3073 | mstore(0x60, m3) |
| 3074 | mstore(0x80, m4) |
| 3075 | } |
| 3076 | } |
| 3077 | |
| 3078 | function log(address p0, address p1, address p2, bytes32 p3) internal pure { |
| 3079 | bytes32 m0; |
| 3080 | bytes32 m1; |
| 3081 | bytes32 m2; |
| 3082 | bytes32 m3; |
| 3083 | bytes32 m4; |
| 3084 | bytes32 m5; |
| 3085 | bytes32 m6; |
| 3086 | /// @solidity memory-safe-assembly |
| 3087 | assembly { |
| 3088 | function writeString(pos, w) { |
| 3089 | let length := 0 |
| 3090 | for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } |
| 3091 | mstore(pos, length) |
| 3092 | let shift := sub(256, shl(3, length)) |
| 3093 | mstore(add(pos, 0x20), shl(shift, shr(shift, w))) |
| 3094 | } |
| 3095 | m0 := mload(0x00) |
| 3096 | m1 := mload(0x20) |
| 3097 | m2 := mload(0x40) |
| 3098 | m3 := mload(0x60) |
| 3099 | m4 := mload(0x80) |
| 3100 | m5 := mload(0xa0) |
| 3101 | m6 := mload(0xc0) |
| 3102 | // Selector of `log(address,address,address,string)`. |
| 3103 | mstore(0x00, 0xf808da20) |
| 3104 | mstore(0x20, p0) |
| 3105 | mstore(0x40, p1) |
| 3106 | mstore(0x60, p2) |
| 3107 | mstore(0x80, 0x80) |
| 3108 | writeString(0xa0, p3) |
| 3109 | } |
| 3110 | _sendLogPayload(0x1c, 0xc4); |
| 3111 | /// @solidity memory-safe-assembly |
| 3112 | assembly { |
| 3113 | mstore(0x00, m0) |
| 3114 | mstore(0x20, m1) |
| 3115 | mstore(0x40, m2) |
| 3116 | mstore(0x60, m3) |
| 3117 | mstore(0x80, m4) |
| 3118 | mstore(0xa0, m5) |
| 3119 | mstore(0xc0, m6) |
| 3120 | } |
| 3121 | } |
| 3122 | |
| 3123 | function log(address p0, address p1, bool p2, address p3) internal pure { |
| 3124 | bytes32 m0; |
| 3125 | bytes32 m1; |
| 3126 | bytes32 m2; |
| 3127 | bytes32 m3; |
| 3128 | bytes32 m4; |
| 3129 | /// @solidity memory-safe-assembly |
| 3130 | assembly { |
| 3131 | m0 := mload(0x00) |
| 3132 | m1 := mload(0x20) |
| 3133 | m2 := mload(0x40) |
| 3134 | m3 := mload(0x60) |
| 3135 | m4 := mload(0x80) |
| 3136 | // Selector of `log(address,address,bool,address)`. |
| 3137 | mstore(0x00, 0x9f1bc36e) |
| 3138 | mstore(0x20, p0) |
| 3139 | mstore(0x40, p1) |
| 3140 | mstore(0x60, p2) |
| 3141 | mstore(0x80, p3) |
| 3142 | } |
| 3143 | _sendLogPayload(0x1c, 0x84); |
| 3144 | /// @solidity memory-safe-assembly |
| 3145 | assembly { |
| 3146 | mstore(0x00, m0) |
| 3147 | mstore(0x20, m1) |
| 3148 | mstore(0x40, m2) |
| 3149 | mstore(0x60, m3) |
| 3150 | mstore(0x80, m4) |
| 3151 | } |
| 3152 | } |
| 3153 | |
| 3154 | function log(address p0, address p1, bool p2, bool p3) internal pure { |
| 3155 | bytes32 m0; |
| 3156 | bytes32 m1; |
| 3157 | bytes32 m2; |
| 3158 | bytes32 m3; |
| 3159 | bytes32 m4; |
| 3160 | /// @solidity memory-safe-assembly |
| 3161 | assembly { |
| 3162 | m0 := mload(0x00) |
| 3163 | m1 := mload(0x20) |
| 3164 | m2 := mload(0x40) |
| 3165 | m3 := mload(0x60) |
| 3166 | m4 := mload(0x80) |
| 3167 | // Selector of `log(address,address,bool,bool)`. |
| 3168 | mstore(0x00, 0x2cd4134a) |
| 3169 | mstore(0x20, p0) |
| 3170 | mstore(0x40, p1) |
| 3171 | mstore(0x60, p2) |
| 3172 | mstore(0x80, p3) |
| 3173 | } |
| 3174 | _sendLogPayload(0x1c, 0x84); |
| 3175 | /// @solidity memory-safe-assembly |
| 3176 | assembly { |
| 3177 | mstore(0x00, m0) |
| 3178 | mstore(0x20, m1) |
| 3179 | mstore(0x40, m2) |
| 3180 | mstore(0x60, m3) |
| 3181 | mstore(0x80, m4) |
| 3182 | } |
| 3183 | } |
| 3184 | |
| 3185 | function log(address p0, address p1, bool p2, uint256 p3) internal pure { |
| 3186 | bytes32 m0; |
| 3187 | bytes32 m1; |
| 3188 | bytes32 m2; |
| 3189 | bytes32 m3; |
| 3190 | bytes32 m4; |
| 3191 | /// @solidity memory-safe-assembly |
| 3192 | assembly { |
| 3193 | m0 := mload(0x00) |
| 3194 | m1 := mload(0x20) |
| 3195 | m2 := mload(0x40) |
| 3196 | m3 := mload(0x60) |
| 3197 | m4 := mload(0x80) |
| 3198 | // Selector of `log(address,address,bool,uint256)`. |
| 3199 | mstore(0x00, 0x3971e78c) |
| 3200 | mstore(0x20, p0) |
| 3201 | mstore(0x40, p1) |
| 3202 | mstore(0x60, p2) |
| 3203 | mstore(0x80, p3) |
| 3204 | } |
| 3205 | _sendLogPayload(0x1c, 0x84); |
| 3206 | /// @solidity memory-safe-assembly |
| 3207 | assembly { |
| 3208 | mstore(0x00, m0) |
| 3209 | mstore(0x20, m1) |
| 3210 | mstore(0x40, m2) |
| 3211 | mstore(0x60, m3) |
| 3212 | mstore(0x80, m4) |
| 3213 | } |
| 3214 | } |
| 3215 | |
| 3216 | function log(address p0, address p1, bool p2, bytes32 p3) internal pure { |
| 3217 | bytes32 m0; |
| 3218 | bytes32 m1; |
| 3219 | bytes32 m2; |
| 3220 | bytes32 m3; |
| 3221 | bytes32 m4; |
| 3222 | bytes32 m5; |
| 3223 | bytes32 m6; |
| 3224 | /// @solidity memory-safe-assembly |
| 3225 | assembly { |
| 3226 | function writeString(pos, w) { |
| 3227 | let length := 0 |
| 3228 | for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } |
| 3229 | mstore(pos, length) |
| 3230 | let shift := sub(256, shl(3, length)) |
| 3231 | mstore(add(pos, 0x20), shl(shift, shr(shift, w))) |
| 3232 | } |
| 3233 | m0 := mload(0x00) |
| 3234 | m1 := mload(0x20) |
| 3235 | m2 := mload(0x40) |
| 3236 | m3 := mload(0x60) |
| 3237 | m4 := mload(0x80) |
| 3238 | m5 := mload(0xa0) |
| 3239 | m6 := mload(0xc0) |
| 3240 | // Selector of `log(address,address,bool,string)`. |
| 3241 | mstore(0x00, 0xaa6540c8) |
| 3242 | mstore(0x20, p0) |
| 3243 | mstore(0x40, p1) |
| 3244 | mstore(0x60, p2) |
| 3245 | mstore(0x80, 0x80) |
| 3246 | writeString(0xa0, p3) |
| 3247 | } |
| 3248 | _sendLogPayload(0x1c, 0xc4); |
| 3249 | /// @solidity memory-safe-assembly |
| 3250 | assembly { |
| 3251 | mstore(0x00, m0) |
| 3252 | mstore(0x20, m1) |
| 3253 | mstore(0x40, m2) |
| 3254 | mstore(0x60, m3) |
| 3255 | mstore(0x80, m4) |
| 3256 | mstore(0xa0, m5) |
| 3257 | mstore(0xc0, m6) |
| 3258 | } |
| 3259 | } |
| 3260 | |
| 3261 | function log(address p0, address p1, uint256 p2, address p3) internal pure { |
| 3262 | bytes32 m0; |
| 3263 | bytes32 m1; |
| 3264 | bytes32 m2; |
| 3265 | bytes32 m3; |
| 3266 | bytes32 m4; |
| 3267 | /// @solidity memory-safe-assembly |
| 3268 | assembly { |
| 3269 | m0 := mload(0x00) |
| 3270 | m1 := mload(0x20) |
| 3271 | m2 := mload(0x40) |
| 3272 | m3 := mload(0x60) |
| 3273 | m4 := mload(0x80) |
| 3274 | // Selector of `log(address,address,uint256,address)`. |
| 3275 | mstore(0x00, 0x8da6def5) |
| 3276 | mstore(0x20, p0) |
| 3277 | mstore(0x40, p1) |
| 3278 | mstore(0x60, p2) |
| 3279 | mstore(0x80, p3) |
| 3280 | } |
| 3281 | _sendLogPayload(0x1c, 0x84); |
| 3282 | /// @solidity memory-safe-assembly |
| 3283 | assembly { |
| 3284 | mstore(0x00, m0) |
| 3285 | mstore(0x20, m1) |
| 3286 | mstore(0x40, m2) |
| 3287 | mstore(0x60, m3) |
| 3288 | mstore(0x80, m4) |
| 3289 | } |
| 3290 | } |
| 3291 | |
| 3292 | function log(address p0, address p1, uint256 p2, bool p3) internal pure { |
| 3293 | bytes32 m0; |
| 3294 | bytes32 m1; |
| 3295 | bytes32 m2; |
| 3296 | bytes32 m3; |
| 3297 | bytes32 m4; |
| 3298 | /// @solidity memory-safe-assembly |
| 3299 | assembly { |
| 3300 | m0 := mload(0x00) |
| 3301 | m1 := mload(0x20) |
| 3302 | m2 := mload(0x40) |
| 3303 | m3 := mload(0x60) |
| 3304 | m4 := mload(0x80) |
| 3305 | // Selector of `log(address,address,uint256,bool)`. |
| 3306 | mstore(0x00, 0x9b4254e2) |
| 3307 | mstore(0x20, p0) |
| 3308 | mstore(0x40, p1) |
| 3309 | mstore(0x60, p2) |
| 3310 | mstore(0x80, p3) |
| 3311 | } |
| 3312 | _sendLogPayload(0x1c, 0x84); |
| 3313 | /// @solidity memory-safe-assembly |
| 3314 | assembly { |
| 3315 | mstore(0x00, m0) |
| 3316 | mstore(0x20, m1) |
| 3317 | mstore(0x40, m2) |
| 3318 | mstore(0x60, m3) |
| 3319 | mstore(0x80, m4) |
| 3320 | } |
| 3321 | } |
| 3322 | |
| 3323 | function log(address p0, address p1, uint256 p2, uint256 p3) internal pure { |
| 3324 | bytes32 m0; |
| 3325 | bytes32 m1; |
| 3326 | bytes32 m2; |
| 3327 | bytes32 m3; |
| 3328 | bytes32 m4; |
| 3329 | /// @solidity memory-safe-assembly |
| 3330 | assembly { |
| 3331 | m0 := mload(0x00) |
| 3332 | m1 := mload(0x20) |
| 3333 | m2 := mload(0x40) |
| 3334 | m3 := mload(0x60) |
| 3335 | m4 := mload(0x80) |
| 3336 | // Selector of `log(address,address,uint256,uint256)`. |
| 3337 | mstore(0x00, 0xbe553481) |
| 3338 | mstore(0x20, p0) |
| 3339 | mstore(0x40, p1) |
| 3340 | mstore(0x60, p2) |
| 3341 | mstore(0x80, p3) |
| 3342 | } |
| 3343 | _sendLogPayload(0x1c, 0x84); |
| 3344 | /// @solidity memory-safe-assembly |
| 3345 | assembly { |
| 3346 | mstore(0x00, m0) |
| 3347 | mstore(0x20, m1) |
| 3348 | mstore(0x40, m2) |
| 3349 | mstore(0x60, m3) |
| 3350 | mstore(0x80, m4) |
| 3351 | } |
| 3352 | } |
| 3353 | |
| 3354 | function log(address p0, address p1, uint256 p2, bytes32 p3) internal pure { |
| 3355 | bytes32 m0; |
| 3356 | bytes32 m1; |
| 3357 | bytes32 m2; |
| 3358 | bytes32 m3; |
| 3359 | bytes32 m4; |
| 3360 | bytes32 m5; |
| 3361 | bytes32 m6; |
| 3362 | /// @solidity memory-safe-assembly |
| 3363 | assembly { |
| 3364 | function writeString(pos, w) { |
| 3365 | let length := 0 |
| 3366 | for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } |
| 3367 | mstore(pos, length) |
| 3368 | let shift := sub(256, shl(3, length)) |
| 3369 | mstore(add(pos, 0x20), shl(shift, shr(shift, w))) |
| 3370 | } |
| 3371 | m0 := mload(0x00) |
| 3372 | m1 := mload(0x20) |
| 3373 | m2 := mload(0x40) |
| 3374 | m3 := mload(0x60) |
| 3375 | m4 := mload(0x80) |
| 3376 | m5 := mload(0xa0) |
| 3377 | m6 := mload(0xc0) |
| 3378 | // Selector of `log(address,address,uint256,string)`. |
| 3379 | mstore(0x00, 0xfdb4f990) |
| 3380 | mstore(0x20, p0) |
| 3381 | mstore(0x40, p1) |
| 3382 | mstore(0x60, p2) |
| 3383 | mstore(0x80, 0x80) |
| 3384 | writeString(0xa0, p3) |
| 3385 | } |
| 3386 | _sendLogPayload(0x1c, 0xc4); |
| 3387 | /// @solidity memory-safe-assembly |
| 3388 | assembly { |
| 3389 | mstore(0x00, m0) |
| 3390 | mstore(0x20, m1) |
| 3391 | mstore(0x40, m2) |
| 3392 | mstore(0x60, m3) |
| 3393 | mstore(0x80, m4) |
| 3394 | mstore(0xa0, m5) |
| 3395 | mstore(0xc0, m6) |
| 3396 | } |
| 3397 | } |
| 3398 | |
| 3399 | function log(address p0, address p1, bytes32 p2, address p3) internal pure { |
| 3400 | bytes32 m0; |
| 3401 | bytes32 m1; |
| 3402 | bytes32 m2; |
| 3403 | bytes32 m3; |
| 3404 | bytes32 m4; |
| 3405 | bytes32 m5; |
| 3406 | bytes32 m6; |
| 3407 | /// @solidity memory-safe-assembly |
| 3408 | assembly { |
| 3409 | function writeString(pos, w) { |
| 3410 | let length := 0 |
| 3411 | for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } |
| 3412 | mstore(pos, length) |
| 3413 | let shift := sub(256, shl(3, length)) |
| 3414 | mstore(add(pos, 0x20), shl(shift, shr(shift, w))) |
| 3415 | } |
| 3416 | m0 := mload(0x00) |
| 3417 | m1 := mload(0x20) |
| 3418 | m2 := mload(0x40) |
| 3419 | m3 := mload(0x60) |
| 3420 | m4 := mload(0x80) |
| 3421 | m5 := mload(0xa0) |
| 3422 | m6 := mload(0xc0) |
| 3423 | // Selector of `log(address,address,string,address)`. |
| 3424 | mstore(0x00, 0x8f736d16) |
| 3425 | mstore(0x20, p0) |
| 3426 | mstore(0x40, p1) |
| 3427 | mstore(0x60, 0x80) |
| 3428 | mstore(0x80, p3) |
| 3429 | writeString(0xa0, p2) |
| 3430 | } |
| 3431 | _sendLogPayload(0x1c, 0xc4); |
| 3432 | /// @solidity memory-safe-assembly |
| 3433 | assembly { |
| 3434 | mstore(0x00, m0) |
| 3435 | mstore(0x20, m1) |
| 3436 | mstore(0x40, m2) |
| 3437 | mstore(0x60, m3) |
| 3438 | mstore(0x80, m4) |
| 3439 | mstore(0xa0, m5) |
| 3440 | mstore(0xc0, m6) |
| 3441 | } |
| 3442 | } |
| 3443 | |
| 3444 | function log(address p0, address p1, bytes32 p2, bool p3) internal pure { |
| 3445 | bytes32 m0; |
| 3446 | bytes32 m1; |
| 3447 | bytes32 m2; |
| 3448 | bytes32 m3; |
| 3449 | bytes32 m4; |
| 3450 | bytes32 m5; |
| 3451 | bytes32 m6; |
| 3452 | /// @solidity memory-safe-assembly |
| 3453 | assembly { |
| 3454 | function writeString(pos, w) { |
| 3455 | let length := 0 |
| 3456 | for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } |
| 3457 | mstore(pos, length) |
| 3458 | let shift := sub(256, shl(3, length)) |
| 3459 | mstore(add(pos, 0x20), shl(shift, shr(shift, w))) |
| 3460 | } |
| 3461 | m0 := mload(0x00) |
| 3462 | m1 := mload(0x20) |
| 3463 | m2 := mload(0x40) |
| 3464 | m3 := mload(0x60) |
| 3465 | m4 := mload(0x80) |
| 3466 | m5 := mload(0xa0) |
| 3467 | m6 := mload(0xc0) |
| 3468 | // Selector of `log(address,address,string,bool)`. |
| 3469 | mstore(0x00, 0x6f1a594e) |
| 3470 | mstore(0x20, p0) |
| 3471 | mstore(0x40, p1) |
| 3472 | mstore(0x60, 0x80) |
| 3473 | mstore(0x80, p3) |
| 3474 | writeString(0xa0, p2) |
| 3475 | } |
| 3476 | _sendLogPayload(0x1c, 0xc4); |
| 3477 | /// @solidity memory-safe-assembly |
| 3478 | assembly { |
| 3479 | mstore(0x00, m0) |
| 3480 | mstore(0x20, m1) |
| 3481 | mstore(0x40, m2) |
| 3482 | mstore(0x60, m3) |
| 3483 | mstore(0x80, m4) |
| 3484 | mstore(0xa0, m5) |
| 3485 | mstore(0xc0, m6) |
| 3486 | } |
| 3487 | } |
| 3488 | |
| 3489 | function log(address p0, address p1, bytes32 p2, uint256 p3) internal pure { |
| 3490 | bytes32 m0; |
| 3491 | bytes32 m1; |
| 3492 | bytes32 m2; |
| 3493 | bytes32 m3; |
| 3494 | bytes32 m4; |
| 3495 | bytes32 m5; |
| 3496 | bytes32 m6; |
| 3497 | /// @solidity memory-safe-assembly |
| 3498 | assembly { |
| 3499 | function writeString(pos, w) { |
| 3500 | let length := 0 |
| 3501 | for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } |
| 3502 | mstore(pos, length) |
| 3503 | let shift := sub(256, shl(3, length)) |
| 3504 | mstore(add(pos, 0x20), shl(shift, shr(shift, w))) |
| 3505 | } |
| 3506 | m0 := mload(0x00) |
| 3507 | m1 := mload(0x20) |
| 3508 | m2 := mload(0x40) |
| 3509 | m3 := mload(0x60) |
| 3510 | m4 := mload(0x80) |
| 3511 | m5 := mload(0xa0) |
| 3512 | m6 := mload(0xc0) |
| 3513 | // Selector of `log(address,address,string,uint256)`. |
| 3514 | mstore(0x00, 0xef1cefe7) |
| 3515 | mstore(0x20, p0) |
| 3516 | mstore(0x40, p1) |
| 3517 | mstore(0x60, 0x80) |
| 3518 | mstore(0x80, p3) |
| 3519 | writeString(0xa0, p2) |
| 3520 | } |
| 3521 | _sendLogPayload(0x1c, 0xc4); |
| 3522 | /// @solidity memory-safe-assembly |
| 3523 | assembly { |
| 3524 | mstore(0x00, m0) |
| 3525 | mstore(0x20, m1) |
| 3526 | mstore(0x40, m2) |
| 3527 | mstore(0x60, m3) |
| 3528 | mstore(0x80, m4) |
| 3529 | mstore(0xa0, m5) |
| 3530 | mstore(0xc0, m6) |
| 3531 | } |
| 3532 | } |
| 3533 | |
| 3534 | function log(address p0, address p1, bytes32 p2, bytes32 p3) internal pure { |
| 3535 | bytes32 m0; |
| 3536 | bytes32 m1; |
| 3537 | bytes32 m2; |
| 3538 | bytes32 m3; |
| 3539 | bytes32 m4; |
| 3540 | bytes32 m5; |
| 3541 | bytes32 m6; |
| 3542 | bytes32 m7; |
| 3543 | bytes32 m8; |
| 3544 | /// @solidity memory-safe-assembly |
| 3545 | assembly { |
| 3546 | function writeString(pos, w) { |
| 3547 | let length := 0 |
| 3548 | for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } |
| 3549 | mstore(pos, length) |
| 3550 | let shift := sub(256, shl(3, length)) |
| 3551 | mstore(add(pos, 0x20), shl(shift, shr(shift, w))) |
| 3552 | } |
| 3553 | m0 := mload(0x00) |
| 3554 | m1 := mload(0x20) |
| 3555 | m2 := mload(0x40) |
| 3556 | m3 := mload(0x60) |
| 3557 | m4 := mload(0x80) |
| 3558 | m5 := mload(0xa0) |
| 3559 | m6 := mload(0xc0) |
| 3560 | m7 := mload(0xe0) |
| 3561 | m8 := mload(0x100) |
| 3562 | // Selector of `log(address,address,string,string)`. |
| 3563 | mstore(0x00, 0x21bdaf25) |
| 3564 | mstore(0x20, p0) |
| 3565 | mstore(0x40, p1) |
| 3566 | mstore(0x60, 0x80) |
| 3567 | mstore(0x80, 0xc0) |
| 3568 | writeString(0xa0, p2) |
| 3569 | writeString(0xe0, p3) |
| 3570 | } |
| 3571 | _sendLogPayload(0x1c, 0x104); |
| 3572 | /// @solidity memory-safe-assembly |
| 3573 | assembly { |
| 3574 | mstore(0x00, m0) |
| 3575 | mstore(0x20, m1) |
| 3576 | mstore(0x40, m2) |
| 3577 | mstore(0x60, m3) |
| 3578 | mstore(0x80, m4) |
| 3579 | mstore(0xa0, m5) |
| 3580 | mstore(0xc0, m6) |
| 3581 | mstore(0xe0, m7) |
| 3582 | mstore(0x100, m8) |
| 3583 | } |
| 3584 | } |
| 3585 | |
| 3586 | function log(address p0, bool p1, address p2, address p3) internal pure { |
| 3587 | bytes32 m0; |
| 3588 | bytes32 m1; |
| 3589 | bytes32 m2; |
| 3590 | bytes32 m3; |
| 3591 | bytes32 m4; |
| 3592 | /// @solidity memory-safe-assembly |
| 3593 | assembly { |
| 3594 | m0 := mload(0x00) |
| 3595 | m1 := mload(0x20) |
| 3596 | m2 := mload(0x40) |
| 3597 | m3 := mload(0x60) |
| 3598 | m4 := mload(0x80) |
| 3599 | // Selector of `log(address,bool,address,address)`. |
| 3600 | mstore(0x00, 0x660375dd) |
| 3601 | mstore(0x20, p0) |
| 3602 | mstore(0x40, p1) |
| 3603 | mstore(0x60, p2) |
| 3604 | mstore(0x80, p3) |
| 3605 | } |
| 3606 | _sendLogPayload(0x1c, 0x84); |
| 3607 | /// @solidity memory-safe-assembly |
| 3608 | assembly { |
| 3609 | mstore(0x00, m0) |
| 3610 | mstore(0x20, m1) |
| 3611 | mstore(0x40, m2) |
| 3612 | mstore(0x60, m3) |
| 3613 | mstore(0x80, m4) |
| 3614 | } |
| 3615 | } |
| 3616 | |
| 3617 | function log(address p0, bool p1, address p2, bool p3) internal pure { |
| 3618 | bytes32 m0; |
| 3619 | bytes32 m1; |
| 3620 | bytes32 m2; |
| 3621 | bytes32 m3; |
| 3622 | bytes32 m4; |
| 3623 | /// @solidity memory-safe-assembly |
| 3624 | assembly { |
| 3625 | m0 := mload(0x00) |
| 3626 | m1 := mload(0x20) |
| 3627 | m2 := mload(0x40) |
| 3628 | m3 := mload(0x60) |
| 3629 | m4 := mload(0x80) |
| 3630 | // Selector of `log(address,bool,address,bool)`. |
| 3631 | mstore(0x00, 0xa6f50b0f) |
| 3632 | mstore(0x20, p0) |
| 3633 | mstore(0x40, p1) |
| 3634 | mstore(0x60, p2) |
| 3635 | mstore(0x80, p3) |
| 3636 | } |
| 3637 | _sendLogPayload(0x1c, 0x84); |
| 3638 | /// @solidity memory-safe-assembly |
| 3639 | assembly { |
| 3640 | mstore(0x00, m0) |
| 3641 | mstore(0x20, m1) |
| 3642 | mstore(0x40, m2) |
| 3643 | mstore(0x60, m3) |
| 3644 | mstore(0x80, m4) |
| 3645 | } |
| 3646 | } |
| 3647 | |
| 3648 | function log(address p0, bool p1, address p2, uint256 p3) internal pure { |
| 3649 | bytes32 m0; |
| 3650 | bytes32 m1; |
| 3651 | bytes32 m2; |
| 3652 | bytes32 m3; |
| 3653 | bytes32 m4; |
| 3654 | /// @solidity memory-safe-assembly |
| 3655 | assembly { |
| 3656 | m0 := mload(0x00) |
| 3657 | m1 := mload(0x20) |
| 3658 | m2 := mload(0x40) |
| 3659 | m3 := mload(0x60) |
| 3660 | m4 := mload(0x80) |
| 3661 | // Selector of `log(address,bool,address,uint256)`. |
| 3662 | mstore(0x00, 0xa75c59de) |
| 3663 | mstore(0x20, p0) |
| 3664 | mstore(0x40, p1) |
| 3665 | mstore(0x60, p2) |
| 3666 | mstore(0x80, p3) |
| 3667 | } |
| 3668 | _sendLogPayload(0x1c, 0x84); |
| 3669 | /// @solidity memory-safe-assembly |
| 3670 | assembly { |
| 3671 | mstore(0x00, m0) |
| 3672 | mstore(0x20, m1) |
| 3673 | mstore(0x40, m2) |
| 3674 | mstore(0x60, m3) |
| 3675 | mstore(0x80, m4) |
| 3676 | } |
| 3677 | } |
| 3678 | |
| 3679 | function log(address p0, bool p1, address p2, bytes32 p3) internal pure { |
| 3680 | bytes32 m0; |
| 3681 | bytes32 m1; |
| 3682 | bytes32 m2; |
| 3683 | bytes32 m3; |
| 3684 | bytes32 m4; |
| 3685 | bytes32 m5; |
| 3686 | bytes32 m6; |
| 3687 | /// @solidity memory-safe-assembly |
| 3688 | assembly { |
| 3689 | function writeString(pos, w) { |
| 3690 | let length := 0 |
| 3691 | for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } |
| 3692 | mstore(pos, length) |
| 3693 | let shift := sub(256, shl(3, length)) |
| 3694 | mstore(add(pos, 0x20), shl(shift, shr(shift, w))) |
| 3695 | } |
| 3696 | m0 := mload(0x00) |
| 3697 | m1 := mload(0x20) |
| 3698 | m2 := mload(0x40) |
| 3699 | m3 := mload(0x60) |
| 3700 | m4 := mload(0x80) |
| 3701 | m5 := mload(0xa0) |
| 3702 | m6 := mload(0xc0) |
| 3703 | // Selector of `log(address,bool,address,string)`. |
| 3704 | mstore(0x00, 0x2dd778e6) |
| 3705 | mstore(0x20, p0) |
| 3706 | mstore(0x40, p1) |
| 3707 | mstore(0x60, p2) |
| 3708 | mstore(0x80, 0x80) |
| 3709 | writeString(0xa0, p3) |
| 3710 | } |
| 3711 | _sendLogPayload(0x1c, 0xc4); |
| 3712 | /// @solidity memory-safe-assembly |
| 3713 | assembly { |
| 3714 | mstore(0x00, m0) |
| 3715 | mstore(0x20, m1) |
| 3716 | mstore(0x40, m2) |
| 3717 | mstore(0x60, m3) |
| 3718 | mstore(0x80, m4) |
| 3719 | mstore(0xa0, m5) |
| 3720 | mstore(0xc0, m6) |
| 3721 | } |
| 3722 | } |
| 3723 | |
| 3724 | function log(address p0, bool p1, bool p2, address p3) internal pure { |
| 3725 | bytes32 m0; |
| 3726 | bytes32 m1; |
| 3727 | bytes32 m2; |
| 3728 | bytes32 m3; |
| 3729 | bytes32 m4; |
| 3730 | /// @solidity memory-safe-assembly |
| 3731 | assembly { |
| 3732 | m0 := mload(0x00) |
| 3733 | m1 := mload(0x20) |
| 3734 | m2 := mload(0x40) |
| 3735 | m3 := mload(0x60) |
| 3736 | m4 := mload(0x80) |
| 3737 | // Selector of `log(address,bool,bool,address)`. |
| 3738 | mstore(0x00, 0xcf394485) |
| 3739 | mstore(0x20, p0) |
| 3740 | mstore(0x40, p1) |
| 3741 | mstore(0x60, p2) |
| 3742 | mstore(0x80, p3) |
| 3743 | } |
| 3744 | _sendLogPayload(0x1c, 0x84); |
| 3745 | /// @solidity memory-safe-assembly |
| 3746 | assembly { |
| 3747 | mstore(0x00, m0) |
| 3748 | mstore(0x20, m1) |
| 3749 | mstore(0x40, m2) |
| 3750 | mstore(0x60, m3) |
| 3751 | mstore(0x80, m4) |
| 3752 | } |
| 3753 | } |
| 3754 | |
| 3755 | function log(address p0, bool p1, bool p2, bool p3) internal pure { |
| 3756 | bytes32 m0; |
| 3757 | bytes32 m1; |
| 3758 | bytes32 m2; |
| 3759 | bytes32 m3; |
| 3760 | bytes32 m4; |
| 3761 | /// @solidity memory-safe-assembly |
| 3762 | assembly { |
| 3763 | m0 := mload(0x00) |
| 3764 | m1 := mload(0x20) |
| 3765 | m2 := mload(0x40) |
| 3766 | m3 := mload(0x60) |
| 3767 | m4 := mload(0x80) |
| 3768 | // Selector of `log(address,bool,bool,bool)`. |
| 3769 | mstore(0x00, 0xcac43479) |
| 3770 | mstore(0x20, p0) |
| 3771 | mstore(0x40, p1) |
| 3772 | mstore(0x60, p2) |
| 3773 | mstore(0x80, p3) |
| 3774 | } |
| 3775 | _sendLogPayload(0x1c, 0x84); |
| 3776 | /// @solidity memory-safe-assembly |
| 3777 | assembly { |
| 3778 | mstore(0x00, m0) |
| 3779 | mstore(0x20, m1) |
| 3780 | mstore(0x40, m2) |
| 3781 | mstore(0x60, m3) |
| 3782 | mstore(0x80, m4) |
| 3783 | } |
| 3784 | } |
| 3785 | |
| 3786 | function log(address p0, bool p1, bool p2, uint256 p3) internal pure { |
| 3787 | bytes32 m0; |
| 3788 | bytes32 m1; |
| 3789 | bytes32 m2; |
| 3790 | bytes32 m3; |
| 3791 | bytes32 m4; |
| 3792 | /// @solidity memory-safe-assembly |
| 3793 | assembly { |
| 3794 | m0 := mload(0x00) |
| 3795 | m1 := mload(0x20) |
| 3796 | m2 := mload(0x40) |
| 3797 | m3 := mload(0x60) |
| 3798 | m4 := mload(0x80) |
| 3799 | // Selector of `log(address,bool,bool,uint256)`. |
| 3800 | mstore(0x00, 0x8c4e5de6) |
| 3801 | mstore(0x20, p0) |
| 3802 | mstore(0x40, p1) |
| 3803 | mstore(0x60, p2) |
| 3804 | mstore(0x80, p3) |
| 3805 | } |
| 3806 | _sendLogPayload(0x1c, 0x84); |
| 3807 | /// @solidity memory-safe-assembly |
| 3808 | assembly { |
| 3809 | mstore(0x00, m0) |
| 3810 | mstore(0x20, m1) |
| 3811 | mstore(0x40, m2) |
| 3812 | mstore(0x60, m3) |
| 3813 | mstore(0x80, m4) |
| 3814 | } |
| 3815 | } |
| 3816 | |
| 3817 | function log(address p0, bool p1, bool p2, bytes32 p3) internal pure { |
| 3818 | bytes32 m0; |
| 3819 | bytes32 m1; |
| 3820 | bytes32 m2; |
| 3821 | bytes32 m3; |
| 3822 | bytes32 m4; |
| 3823 | bytes32 m5; |
| 3824 | bytes32 m6; |
| 3825 | /// @solidity memory-safe-assembly |
| 3826 | assembly { |
| 3827 | function writeString(pos, w) { |
| 3828 | let length := 0 |
| 3829 | for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } |
| 3830 | mstore(pos, length) |
| 3831 | let shift := sub(256, shl(3, length)) |
| 3832 | mstore(add(pos, 0x20), shl(shift, shr(shift, w))) |
| 3833 | } |
| 3834 | m0 := mload(0x00) |
| 3835 | m1 := mload(0x20) |
| 3836 | m2 := mload(0x40) |
| 3837 | m3 := mload(0x60) |
| 3838 | m4 := mload(0x80) |
| 3839 | m5 := mload(0xa0) |
| 3840 | m6 := mload(0xc0) |
| 3841 | // Selector of `log(address,bool,bool,string)`. |
| 3842 | mstore(0x00, 0xdfc4a2e8) |
| 3843 | mstore(0x20, p0) |
| 3844 | mstore(0x40, p1) |
| 3845 | mstore(0x60, p2) |
| 3846 | mstore(0x80, 0x80) |
| 3847 | writeString(0xa0, p3) |
| 3848 | } |
| 3849 | _sendLogPayload(0x1c, 0xc4); |
| 3850 | /// @solidity memory-safe-assembly |
| 3851 | assembly { |
| 3852 | mstore(0x00, m0) |
| 3853 | mstore(0x20, m1) |
| 3854 | mstore(0x40, m2) |
| 3855 | mstore(0x60, m3) |
| 3856 | mstore(0x80, m4) |
| 3857 | mstore(0xa0, m5) |
| 3858 | mstore(0xc0, m6) |
| 3859 | } |
| 3860 | } |
| 3861 | |
| 3862 | function log(address p0, bool p1, uint256 p2, address p3) internal pure { |
| 3863 | bytes32 m0; |
| 3864 | bytes32 m1; |
| 3865 | bytes32 m2; |
| 3866 | bytes32 m3; |
| 3867 | bytes32 m4; |
| 3868 | /// @solidity memory-safe-assembly |
| 3869 | assembly { |
| 3870 | m0 := mload(0x00) |
| 3871 | m1 := mload(0x20) |
| 3872 | m2 := mload(0x40) |
| 3873 | m3 := mload(0x60) |
| 3874 | m4 := mload(0x80) |
| 3875 | // Selector of `log(address,bool,uint256,address)`. |
| 3876 | mstore(0x00, 0xccf790a1) |
| 3877 | mstore(0x20, p0) |
| 3878 | mstore(0x40, p1) |
| 3879 | mstore(0x60, p2) |
| 3880 | mstore(0x80, p3) |
| 3881 | } |
| 3882 | _sendLogPayload(0x1c, 0x84); |
| 3883 | /// @solidity memory-safe-assembly |
| 3884 | assembly { |
| 3885 | mstore(0x00, m0) |
| 3886 | mstore(0x20, m1) |
| 3887 | mstore(0x40, m2) |
| 3888 | mstore(0x60, m3) |
| 3889 | mstore(0x80, m4) |
| 3890 | } |
| 3891 | } |
| 3892 | |
| 3893 | function log(address p0, bool p1, uint256 p2, bool p3) internal pure { |
| 3894 | bytes32 m0; |
| 3895 | bytes32 m1; |
| 3896 | bytes32 m2; |
| 3897 | bytes32 m3; |
| 3898 | bytes32 m4; |
| 3899 | /// @solidity memory-safe-assembly |
| 3900 | assembly { |
| 3901 | m0 := mload(0x00) |
| 3902 | m1 := mload(0x20) |
| 3903 | m2 := mload(0x40) |
| 3904 | m3 := mload(0x60) |
| 3905 | m4 := mload(0x80) |
| 3906 | // Selector of `log(address,bool,uint256,bool)`. |
| 3907 | mstore(0x00, 0xc4643e20) |
| 3908 | mstore(0x20, p0) |
| 3909 | mstore(0x40, p1) |
| 3910 | mstore(0x60, p2) |
| 3911 | mstore(0x80, p3) |
| 3912 | } |
| 3913 | _sendLogPayload(0x1c, 0x84); |
| 3914 | /// @solidity memory-safe-assembly |
| 3915 | assembly { |
| 3916 | mstore(0x00, m0) |
| 3917 | mstore(0x20, m1) |
| 3918 | mstore(0x40, m2) |
| 3919 | mstore(0x60, m3) |
| 3920 | mstore(0x80, m4) |
| 3921 | } |
| 3922 | } |
| 3923 | |
| 3924 | function log(address p0, bool p1, uint256 p2, uint256 p3) internal pure { |
| 3925 | bytes32 m0; |
| 3926 | bytes32 m1; |
| 3927 | bytes32 m2; |
| 3928 | bytes32 m3; |
| 3929 | bytes32 m4; |
| 3930 | /// @solidity memory-safe-assembly |
| 3931 | assembly { |
| 3932 | m0 := mload(0x00) |
| 3933 | m1 := mload(0x20) |
| 3934 | m2 := mload(0x40) |
| 3935 | m3 := mload(0x60) |
| 3936 | m4 := mload(0x80) |
| 3937 | // Selector of `log(address,bool,uint256,uint256)`. |
| 3938 | mstore(0x00, 0x386ff5f4) |
| 3939 | mstore(0x20, p0) |
| 3940 | mstore(0x40, p1) |
| 3941 | mstore(0x60, p2) |
| 3942 | mstore(0x80, p3) |
| 3943 | } |
| 3944 | _sendLogPayload(0x1c, 0x84); |
| 3945 | /// @solidity memory-safe-assembly |
| 3946 | assembly { |
| 3947 | mstore(0x00, m0) |
| 3948 | mstore(0x20, m1) |
| 3949 | mstore(0x40, m2) |
| 3950 | mstore(0x60, m3) |
| 3951 | mstore(0x80, m4) |
| 3952 | } |
| 3953 | } |
| 3954 | |
| 3955 | function log(address p0, bool p1, uint256 p2, bytes32 p3) internal pure { |
| 3956 | bytes32 m0; |
| 3957 | bytes32 m1; |
| 3958 | bytes32 m2; |
| 3959 | bytes32 m3; |
| 3960 | bytes32 m4; |
| 3961 | bytes32 m5; |
| 3962 | bytes32 m6; |
| 3963 | /// @solidity memory-safe-assembly |
| 3964 | assembly { |
| 3965 | function writeString(pos, w) { |
| 3966 | let length := 0 |
| 3967 | for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } |
| 3968 | mstore(pos, length) |
| 3969 | let shift := sub(256, shl(3, length)) |
| 3970 | mstore(add(pos, 0x20), shl(shift, shr(shift, w))) |
| 3971 | } |
| 3972 | m0 := mload(0x00) |
| 3973 | m1 := mload(0x20) |
| 3974 | m2 := mload(0x40) |
| 3975 | m3 := mload(0x60) |
| 3976 | m4 := mload(0x80) |
| 3977 | m5 := mload(0xa0) |
| 3978 | m6 := mload(0xc0) |
| 3979 | // Selector of `log(address,bool,uint256,string)`. |
| 3980 | mstore(0x00, 0x0aa6cfad) |
| 3981 | mstore(0x20, p0) |
| 3982 | mstore(0x40, p1) |
| 3983 | mstore(0x60, p2) |
| 3984 | mstore(0x80, 0x80) |
| 3985 | writeString(0xa0, p3) |
| 3986 | } |
| 3987 | _sendLogPayload(0x1c, 0xc4); |
| 3988 | /// @solidity memory-safe-assembly |
| 3989 | assembly { |
| 3990 | mstore(0x00, m0) |
| 3991 | mstore(0x20, m1) |
| 3992 | mstore(0x40, m2) |
| 3993 | mstore(0x60, m3) |
| 3994 | mstore(0x80, m4) |
| 3995 | mstore(0xa0, m5) |
| 3996 | mstore(0xc0, m6) |
| 3997 | } |
| 3998 | } |
| 3999 | |
| 4000 | function log(address p0, bool p1, bytes32 p2, address p3) internal pure { |
| 4001 | bytes32 m0; |
| 4002 | bytes32 m1; |
| 4003 | bytes32 m2; |
| 4004 | bytes32 m3; |
| 4005 | bytes32 m4; |
| 4006 | bytes32 m5; |
| 4007 | bytes32 m6; |
| 4008 | /// @solidity memory-safe-assembly |
| 4009 | assembly { |
| 4010 | function writeString(pos, w) { |
| 4011 | let length := 0 |
| 4012 | for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } |
| 4013 | mstore(pos, length) |
| 4014 | let shift := sub(256, shl(3, length)) |
| 4015 | mstore(add(pos, 0x20), shl(shift, shr(shift, w))) |
| 4016 | } |
| 4017 | m0 := mload(0x00) |
| 4018 | m1 := mload(0x20) |
| 4019 | m2 := mload(0x40) |
| 4020 | m3 := mload(0x60) |
| 4021 | m4 := mload(0x80) |
| 4022 | m5 := mload(0xa0) |
| 4023 | m6 := mload(0xc0) |
| 4024 | // Selector of `log(address,bool,string,address)`. |
| 4025 | mstore(0x00, 0x19fd4956) |
| 4026 | mstore(0x20, p0) |
| 4027 | mstore(0x40, p1) |
| 4028 | mstore(0x60, 0x80) |
| 4029 | mstore(0x80, p3) |
| 4030 | writeString(0xa0, p2) |
| 4031 | } |
| 4032 | _sendLogPayload(0x1c, 0xc4); |
| 4033 | /// @solidity memory-safe-assembly |
| 4034 | assembly { |
| 4035 | mstore(0x00, m0) |
| 4036 | mstore(0x20, m1) |
| 4037 | mstore(0x40, m2) |
| 4038 | mstore(0x60, m3) |
| 4039 | mstore(0x80, m4) |
| 4040 | mstore(0xa0, m5) |
| 4041 | mstore(0xc0, m6) |
| 4042 | } |
| 4043 | } |
| 4044 | |
| 4045 | function log(address p0, bool p1, bytes32 p2, bool p3) internal pure { |
| 4046 | bytes32 m0; |
| 4047 | bytes32 m1; |
| 4048 | bytes32 m2; |
| 4049 | bytes32 m3; |
| 4050 | bytes32 m4; |
| 4051 | bytes32 m5; |
| 4052 | bytes32 m6; |
| 4053 | /// @solidity memory-safe-assembly |
| 4054 | assembly { |
| 4055 | function writeString(pos, w) { |
| 4056 | let length := 0 |
| 4057 | for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } |
| 4058 | mstore(pos, length) |
| 4059 | let shift := sub(256, shl(3, length)) |
| 4060 | mstore(add(pos, 0x20), shl(shift, shr(shift, w))) |
| 4061 | } |
| 4062 | m0 := mload(0x00) |
| 4063 | m1 := mload(0x20) |
| 4064 | m2 := mload(0x40) |
| 4065 | m3 := mload(0x60) |
| 4066 | m4 := mload(0x80) |
| 4067 | m5 := mload(0xa0) |
| 4068 | m6 := mload(0xc0) |
| 4069 | // Selector of `log(address,bool,string,bool)`. |
| 4070 | mstore(0x00, 0x50ad461d) |
| 4071 | mstore(0x20, p0) |
| 4072 | mstore(0x40, p1) |
| 4073 | mstore(0x60, 0x80) |
| 4074 | mstore(0x80, p3) |
| 4075 | writeString(0xa0, p2) |
| 4076 | } |
| 4077 | _sendLogPayload(0x1c, 0xc4); |
| 4078 | /// @solidity memory-safe-assembly |
| 4079 | assembly { |
| 4080 | mstore(0x00, m0) |
| 4081 | mstore(0x20, m1) |
| 4082 | mstore(0x40, m2) |
| 4083 | mstore(0x60, m3) |
| 4084 | mstore(0x80, m4) |
| 4085 | mstore(0xa0, m5) |
| 4086 | mstore(0xc0, m6) |
| 4087 | } |
| 4088 | } |
| 4089 | |
| 4090 | function log(address p0, bool p1, bytes32 p2, uint256 p3) internal pure { |
| 4091 | bytes32 m0; |
| 4092 | bytes32 m1; |
| 4093 | bytes32 m2; |
| 4094 | bytes32 m3; |
| 4095 | bytes32 m4; |
| 4096 | bytes32 m5; |
| 4097 | bytes32 m6; |
| 4098 | /// @solidity memory-safe-assembly |
| 4099 | assembly { |
| 4100 | function writeString(pos, w) { |
| 4101 | let length := 0 |
| 4102 | for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } |
| 4103 | mstore(pos, length) |
| 4104 | let shift := sub(256, shl(3, length)) |
| 4105 | mstore(add(pos, 0x20), shl(shift, shr(shift, w))) |
| 4106 | } |
| 4107 | m0 := mload(0x00) |
| 4108 | m1 := mload(0x20) |
| 4109 | m2 := mload(0x40) |
| 4110 | m3 := mload(0x60) |
| 4111 | m4 := mload(0x80) |
| 4112 | m5 := mload(0xa0) |
| 4113 | m6 := mload(0xc0) |
| 4114 | // Selector of `log(address,bool,string,uint256)`. |
| 4115 | mstore(0x00, 0x80e6a20b) |
| 4116 | mstore(0x20, p0) |
| 4117 | mstore(0x40, p1) |
| 4118 | mstore(0x60, 0x80) |
| 4119 | mstore(0x80, p3) |
| 4120 | writeString(0xa0, p2) |
| 4121 | } |
| 4122 | _sendLogPayload(0x1c, 0xc4); |
| 4123 | /// @solidity memory-safe-assembly |
| 4124 | assembly { |
| 4125 | mstore(0x00, m0) |
| 4126 | mstore(0x20, m1) |
| 4127 | mstore(0x40, m2) |
| 4128 | mstore(0x60, m3) |
| 4129 | mstore(0x80, m4) |
| 4130 | mstore(0xa0, m5) |
| 4131 | mstore(0xc0, m6) |
| 4132 | } |
| 4133 | } |
| 4134 | |
| 4135 | function log(address p0, bool p1, bytes32 p2, bytes32 p3) internal pure { |
| 4136 | bytes32 m0; |
| 4137 | bytes32 m1; |
| 4138 | bytes32 m2; |
| 4139 | bytes32 m3; |
| 4140 | bytes32 m4; |
| 4141 | bytes32 m5; |
| 4142 | bytes32 m6; |
| 4143 | bytes32 m7; |
| 4144 | bytes32 m8; |
| 4145 | /// @solidity memory-safe-assembly |
| 4146 | assembly { |
| 4147 | function writeString(pos, w) { |
| 4148 | let length := 0 |
| 4149 | for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } |
| 4150 | mstore(pos, length) |
| 4151 | let shift := sub(256, shl(3, length)) |
| 4152 | mstore(add(pos, 0x20), shl(shift, shr(shift, w))) |
| 4153 | } |
| 4154 | m0 := mload(0x00) |
| 4155 | m1 := mload(0x20) |
| 4156 | m2 := mload(0x40) |
| 4157 | m3 := mload(0x60) |
| 4158 | m4 := mload(0x80) |
| 4159 | m5 := mload(0xa0) |
| 4160 | m6 := mload(0xc0) |
| 4161 | m7 := mload(0xe0) |
| 4162 | m8 := mload(0x100) |
| 4163 | // Selector of `log(address,bool,string,string)`. |
| 4164 | mstore(0x00, 0x475c5c33) |
| 4165 | mstore(0x20, p0) |
| 4166 | mstore(0x40, p1) |
| 4167 | mstore(0x60, 0x80) |
| 4168 | mstore(0x80, 0xc0) |
| 4169 | writeString(0xa0, p2) |
| 4170 | writeString(0xe0, p3) |
| 4171 | } |
| 4172 | _sendLogPayload(0x1c, 0x104); |
| 4173 | /// @solidity memory-safe-assembly |
| 4174 | assembly { |
| 4175 | mstore(0x00, m0) |
| 4176 | mstore(0x20, m1) |
| 4177 | mstore(0x40, m2) |
| 4178 | mstore(0x60, m3) |
| 4179 | mstore(0x80, m4) |
| 4180 | mstore(0xa0, m5) |
| 4181 | mstore(0xc0, m6) |
| 4182 | mstore(0xe0, m7) |
| 4183 | mstore(0x100, m8) |
| 4184 | } |
| 4185 | } |
| 4186 | |
| 4187 | function log(address p0, uint256 p1, address p2, address p3) internal pure { |
| 4188 | bytes32 m0; |
| 4189 | bytes32 m1; |
| 4190 | bytes32 m2; |
| 4191 | bytes32 m3; |
| 4192 | bytes32 m4; |
| 4193 | /// @solidity memory-safe-assembly |
| 4194 | assembly { |
| 4195 | m0 := mload(0x00) |
| 4196 | m1 := mload(0x20) |
| 4197 | m2 := mload(0x40) |
| 4198 | m3 := mload(0x60) |
| 4199 | m4 := mload(0x80) |
| 4200 | // Selector of `log(address,uint256,address,address)`. |
| 4201 | mstore(0x00, 0x478d1c62) |
| 4202 | mstore(0x20, p0) |
| 4203 | mstore(0x40, p1) |
| 4204 | mstore(0x60, p2) |
| 4205 | mstore(0x80, p3) |
| 4206 | } |
| 4207 | _sendLogPayload(0x1c, 0x84); |
| 4208 | /// @solidity memory-safe-assembly |
| 4209 | assembly { |
| 4210 | mstore(0x00, m0) |
| 4211 | mstore(0x20, m1) |
| 4212 | mstore(0x40, m2) |
| 4213 | mstore(0x60, m3) |
| 4214 | mstore(0x80, m4) |
| 4215 | } |
| 4216 | } |
| 4217 | |
| 4218 | function log(address p0, uint256 p1, address p2, bool p3) internal pure { |
| 4219 | bytes32 m0; |
| 4220 | bytes32 m1; |
| 4221 | bytes32 m2; |
| 4222 | bytes32 m3; |
| 4223 | bytes32 m4; |
| 4224 | /// @solidity memory-safe-assembly |
| 4225 | assembly { |
| 4226 | m0 := mload(0x00) |
| 4227 | m1 := mload(0x20) |
| 4228 | m2 := mload(0x40) |
| 4229 | m3 := mload(0x60) |
| 4230 | m4 := mload(0x80) |
| 4231 | // Selector of `log(address,uint256,address,bool)`. |
| 4232 | mstore(0x00, 0xa1bcc9b3) |
| 4233 | mstore(0x20, p0) |
| 4234 | mstore(0x40, p1) |
| 4235 | mstore(0x60, p2) |
| 4236 | mstore(0x80, p3) |
| 4237 | } |
| 4238 | _sendLogPayload(0x1c, 0x84); |
| 4239 | /// @solidity memory-safe-assembly |
| 4240 | assembly { |
| 4241 | mstore(0x00, m0) |
| 4242 | mstore(0x20, m1) |
| 4243 | mstore(0x40, m2) |
| 4244 | mstore(0x60, m3) |
| 4245 | mstore(0x80, m4) |
| 4246 | } |
| 4247 | } |
| 4248 | |
| 4249 | function log(address p0, uint256 p1, address p2, uint256 p3) internal pure { |
| 4250 | bytes32 m0; |
| 4251 | bytes32 m1; |
| 4252 | bytes32 m2; |
| 4253 | bytes32 m3; |
| 4254 | bytes32 m4; |
| 4255 | /// @solidity memory-safe-assembly |
| 4256 | assembly { |
| 4257 | m0 := mload(0x00) |
| 4258 | m1 := mload(0x20) |
| 4259 | m2 := mload(0x40) |
| 4260 | m3 := mload(0x60) |
| 4261 | m4 := mload(0x80) |
| 4262 | // Selector of `log(address,uint256,address,uint256)`. |
| 4263 | mstore(0x00, 0x100f650e) |
| 4264 | mstore(0x20, p0) |
| 4265 | mstore(0x40, p1) |
| 4266 | mstore(0x60, p2) |
| 4267 | mstore(0x80, p3) |
| 4268 | } |
| 4269 | _sendLogPayload(0x1c, 0x84); |
| 4270 | /// @solidity memory-safe-assembly |
| 4271 | assembly { |
| 4272 | mstore(0x00, m0) |
| 4273 | mstore(0x20, m1) |
| 4274 | mstore(0x40, m2) |
| 4275 | mstore(0x60, m3) |
| 4276 | mstore(0x80, m4) |
| 4277 | } |
| 4278 | } |
| 4279 | |
| 4280 | function log(address p0, uint256 p1, address p2, bytes32 p3) internal pure { |
| 4281 | bytes32 m0; |
| 4282 | bytes32 m1; |
| 4283 | bytes32 m2; |
| 4284 | bytes32 m3; |
| 4285 | bytes32 m4; |
| 4286 | bytes32 m5; |
| 4287 | bytes32 m6; |
| 4288 | /// @solidity memory-safe-assembly |
| 4289 | assembly { |
| 4290 | function writeString(pos, w) { |
| 4291 | let length := 0 |
| 4292 | for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } |
| 4293 | mstore(pos, length) |
| 4294 | let shift := sub(256, shl(3, length)) |
| 4295 | mstore(add(pos, 0x20), shl(shift, shr(shift, w))) |
| 4296 | } |
| 4297 | m0 := mload(0x00) |
| 4298 | m1 := mload(0x20) |
| 4299 | m2 := mload(0x40) |
| 4300 | m3 := mload(0x60) |
| 4301 | m4 := mload(0x80) |
| 4302 | m5 := mload(0xa0) |
| 4303 | m6 := mload(0xc0) |
| 4304 | // Selector of `log(address,uint256,address,string)`. |
| 4305 | mstore(0x00, 0x1da986ea) |
| 4306 | mstore(0x20, p0) |
| 4307 | mstore(0x40, p1) |
| 4308 | mstore(0x60, p2) |
| 4309 | mstore(0x80, 0x80) |
| 4310 | writeString(0xa0, p3) |
| 4311 | } |
| 4312 | _sendLogPayload(0x1c, 0xc4); |
| 4313 | /// @solidity memory-safe-assembly |
| 4314 | assembly { |
| 4315 | mstore(0x00, m0) |
| 4316 | mstore(0x20, m1) |
| 4317 | mstore(0x40, m2) |
| 4318 | mstore(0x60, m3) |
| 4319 | mstore(0x80, m4) |
| 4320 | mstore(0xa0, m5) |
| 4321 | mstore(0xc0, m6) |
| 4322 | } |
| 4323 | } |
| 4324 | |
| 4325 | function log(address p0, uint256 p1, bool p2, address p3) internal pure { |
| 4326 | bytes32 m0; |
| 4327 | bytes32 m1; |
| 4328 | bytes32 m2; |
| 4329 | bytes32 m3; |
| 4330 | bytes32 m4; |
| 4331 | /// @solidity memory-safe-assembly |
| 4332 | assembly { |
| 4333 | m0 := mload(0x00) |
| 4334 | m1 := mload(0x20) |
| 4335 | m2 := mload(0x40) |
| 4336 | m3 := mload(0x60) |
| 4337 | m4 := mload(0x80) |
| 4338 | // Selector of `log(address,uint256,bool,address)`. |
| 4339 | mstore(0x00, 0xa31bfdcc) |
| 4340 | mstore(0x20, p0) |
| 4341 | mstore(0x40, p1) |
| 4342 | mstore(0x60, p2) |
| 4343 | mstore(0x80, p3) |
| 4344 | } |
| 4345 | _sendLogPayload(0x1c, 0x84); |
| 4346 | /// @solidity memory-safe-assembly |
| 4347 | assembly { |
| 4348 | mstore(0x00, m0) |
| 4349 | mstore(0x20, m1) |
| 4350 | mstore(0x40, m2) |
| 4351 | mstore(0x60, m3) |
| 4352 | mstore(0x80, m4) |
| 4353 | } |
| 4354 | } |
| 4355 | |
| 4356 | function log(address p0, uint256 p1, bool p2, bool p3) internal pure { |
| 4357 | bytes32 m0; |
| 4358 | bytes32 m1; |
| 4359 | bytes32 m2; |
| 4360 | bytes32 m3; |
| 4361 | bytes32 m4; |
| 4362 | /// @solidity memory-safe-assembly |
| 4363 | assembly { |
| 4364 | m0 := mload(0x00) |
| 4365 | m1 := mload(0x20) |
| 4366 | m2 := mload(0x40) |
| 4367 | m3 := mload(0x60) |
| 4368 | m4 := mload(0x80) |
| 4369 | // Selector of `log(address,uint256,bool,bool)`. |
| 4370 | mstore(0x00, 0x3bf5e537) |
| 4371 | mstore(0x20, p0) |
| 4372 | mstore(0x40, p1) |
| 4373 | mstore(0x60, p2) |
| 4374 | mstore(0x80, p3) |
| 4375 | } |
| 4376 | _sendLogPayload(0x1c, 0x84); |
| 4377 | /// @solidity memory-safe-assembly |
| 4378 | assembly { |
| 4379 | mstore(0x00, m0) |
| 4380 | mstore(0x20, m1) |
| 4381 | mstore(0x40, m2) |
| 4382 | mstore(0x60, m3) |
| 4383 | mstore(0x80, m4) |
| 4384 | } |
| 4385 | } |
| 4386 | |
| 4387 | function log(address p0, uint256 p1, bool p2, uint256 p3) internal pure { |
| 4388 | bytes32 m0; |
| 4389 | bytes32 m1; |
| 4390 | bytes32 m2; |
| 4391 | bytes32 m3; |
| 4392 | bytes32 m4; |
| 4393 | /// @solidity memory-safe-assembly |
| 4394 | assembly { |
| 4395 | m0 := mload(0x00) |
| 4396 | m1 := mload(0x20) |
| 4397 | m2 := mload(0x40) |
| 4398 | m3 := mload(0x60) |
| 4399 | m4 := mload(0x80) |
| 4400 | // Selector of `log(address,uint256,bool,uint256)`. |
| 4401 | mstore(0x00, 0x22f6b999) |
| 4402 | mstore(0x20, p0) |
| 4403 | mstore(0x40, p1) |
| 4404 | mstore(0x60, p2) |
| 4405 | mstore(0x80, p3) |
| 4406 | } |
| 4407 | _sendLogPayload(0x1c, 0x84); |
| 4408 | /// @solidity memory-safe-assembly |
| 4409 | assembly { |
| 4410 | mstore(0x00, m0) |
| 4411 | mstore(0x20, m1) |
| 4412 | mstore(0x40, m2) |
| 4413 | mstore(0x60, m3) |
| 4414 | mstore(0x80, m4) |
| 4415 | } |
| 4416 | } |
| 4417 | |
| 4418 | function log(address p0, uint256 p1, bool p2, bytes32 p3) internal pure { |
| 4419 | bytes32 m0; |
| 4420 | bytes32 m1; |
| 4421 | bytes32 m2; |
| 4422 | bytes32 m3; |
| 4423 | bytes32 m4; |
| 4424 | bytes32 m5; |
| 4425 | bytes32 m6; |
| 4426 | /// @solidity memory-safe-assembly |
| 4427 | assembly { |
| 4428 | function writeString(pos, w) { |
| 4429 | let length := 0 |
| 4430 | for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } |
| 4431 | mstore(pos, length) |
| 4432 | let shift := sub(256, shl(3, length)) |
| 4433 | mstore(add(pos, 0x20), shl(shift, shr(shift, w))) |
| 4434 | } |
| 4435 | m0 := mload(0x00) |
| 4436 | m1 := mload(0x20) |
| 4437 | m2 := mload(0x40) |
| 4438 | m3 := mload(0x60) |
| 4439 | m4 := mload(0x80) |
| 4440 | m5 := mload(0xa0) |
| 4441 | m6 := mload(0xc0) |
| 4442 | // Selector of `log(address,uint256,bool,string)`. |
| 4443 | mstore(0x00, 0xc5ad85f9) |
| 4444 | mstore(0x20, p0) |
| 4445 | mstore(0x40, p1) |
| 4446 | mstore(0x60, p2) |
| 4447 | mstore(0x80, 0x80) |
| 4448 | writeString(0xa0, p3) |
| 4449 | } |
| 4450 | _sendLogPayload(0x1c, 0xc4); |
| 4451 | /// @solidity memory-safe-assembly |
| 4452 | assembly { |
| 4453 | mstore(0x00, m0) |
| 4454 | mstore(0x20, m1) |
| 4455 | mstore(0x40, m2) |
| 4456 | mstore(0x60, m3) |
| 4457 | mstore(0x80, m4) |
| 4458 | mstore(0xa0, m5) |
| 4459 | mstore(0xc0, m6) |
| 4460 | } |
| 4461 | } |
| 4462 | |
| 4463 | function log(address p0, uint256 p1, uint256 p2, address p3) internal pure { |
| 4464 | bytes32 m0; |
| 4465 | bytes32 m1; |
| 4466 | bytes32 m2; |
| 4467 | bytes32 m3; |
| 4468 | bytes32 m4; |
| 4469 | /// @solidity memory-safe-assembly |
| 4470 | assembly { |
| 4471 | m0 := mload(0x00) |
| 4472 | m1 := mload(0x20) |
| 4473 | m2 := mload(0x40) |
| 4474 | m3 := mload(0x60) |
| 4475 | m4 := mload(0x80) |
| 4476 | // Selector of `log(address,uint256,uint256,address)`. |
| 4477 | mstore(0x00, 0x20e3984d) |
| 4478 | mstore(0x20, p0) |
| 4479 | mstore(0x40, p1) |
| 4480 | mstore(0x60, p2) |
| 4481 | mstore(0x80, p3) |
| 4482 | } |
| 4483 | _sendLogPayload(0x1c, 0x84); |
| 4484 | /// @solidity memory-safe-assembly |
| 4485 | assembly { |
| 4486 | mstore(0x00, m0) |
| 4487 | mstore(0x20, m1) |
| 4488 | mstore(0x40, m2) |
| 4489 | mstore(0x60, m3) |
| 4490 | mstore(0x80, m4) |
| 4491 | } |
| 4492 | } |
| 4493 | |
| 4494 | function log(address p0, uint256 p1, uint256 p2, bool p3) internal pure { |
| 4495 | bytes32 m0; |
| 4496 | bytes32 m1; |
| 4497 | bytes32 m2; |
| 4498 | bytes32 m3; |
| 4499 | bytes32 m4; |
| 4500 | /// @solidity memory-safe-assembly |
| 4501 | assembly { |
| 4502 | m0 := mload(0x00) |
| 4503 | m1 := mload(0x20) |
| 4504 | m2 := mload(0x40) |
| 4505 | m3 := mload(0x60) |
| 4506 | m4 := mload(0x80) |
| 4507 | // Selector of `log(address,uint256,uint256,bool)`. |
| 4508 | mstore(0x00, 0x66f1bc67) |
| 4509 | mstore(0x20, p0) |
| 4510 | mstore(0x40, p1) |
| 4511 | mstore(0x60, p2) |
| 4512 | mstore(0x80, p3) |
| 4513 | } |
| 4514 | _sendLogPayload(0x1c, 0x84); |
| 4515 | /// @solidity memory-safe-assembly |
| 4516 | assembly { |
| 4517 | mstore(0x00, m0) |
| 4518 | mstore(0x20, m1) |
| 4519 | mstore(0x40, m2) |
| 4520 | mstore(0x60, m3) |
| 4521 | mstore(0x80, m4) |
| 4522 | } |
| 4523 | } |
| 4524 | |
| 4525 | function log(address p0, uint256 p1, uint256 p2, uint256 p3) internal pure { |
| 4526 | bytes32 m0; |
| 4527 | bytes32 m1; |
| 4528 | bytes32 m2; |
| 4529 | bytes32 m3; |
| 4530 | bytes32 m4; |
| 4531 | /// @solidity memory-safe-assembly |
| 4532 | assembly { |
| 4533 | m0 := mload(0x00) |
| 4534 | m1 := mload(0x20) |
| 4535 | m2 := mload(0x40) |
| 4536 | m3 := mload(0x60) |
| 4537 | m4 := mload(0x80) |
| 4538 | // Selector of `log(address,uint256,uint256,uint256)`. |
| 4539 | mstore(0x00, 0x34f0e636) |
| 4540 | mstore(0x20, p0) |
| 4541 | mstore(0x40, p1) |
| 4542 | mstore(0x60, p2) |
| 4543 | mstore(0x80, p3) |
| 4544 | } |
| 4545 | _sendLogPayload(0x1c, 0x84); |
| 4546 | /// @solidity memory-safe-assembly |
| 4547 | assembly { |
| 4548 | mstore(0x00, m0) |
| 4549 | mstore(0x20, m1) |
| 4550 | mstore(0x40, m2) |
| 4551 | mstore(0x60, m3) |
| 4552 | mstore(0x80, m4) |
| 4553 | } |
| 4554 | } |
| 4555 | |
| 4556 | function log(address p0, uint256 p1, uint256 p2, bytes32 p3) internal pure { |
| 4557 | bytes32 m0; |
| 4558 | bytes32 m1; |
| 4559 | bytes32 m2; |
| 4560 | bytes32 m3; |
| 4561 | bytes32 m4; |
| 4562 | bytes32 m5; |
| 4563 | bytes32 m6; |
| 4564 | /// @solidity memory-safe-assembly |
| 4565 | assembly { |
| 4566 | function writeString(pos, w) { |
| 4567 | let length := 0 |
| 4568 | for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } |
| 4569 | mstore(pos, length) |
| 4570 | let shift := sub(256, shl(3, length)) |
| 4571 | mstore(add(pos, 0x20), shl(shift, shr(shift, w))) |
| 4572 | } |
| 4573 | m0 := mload(0x00) |
| 4574 | m1 := mload(0x20) |
| 4575 | m2 := mload(0x40) |
| 4576 | m3 := mload(0x60) |
| 4577 | m4 := mload(0x80) |
| 4578 | m5 := mload(0xa0) |
| 4579 | m6 := mload(0xc0) |
| 4580 | // Selector of `log(address,uint256,uint256,string)`. |
| 4581 | mstore(0x00, 0x4a28c017) |
| 4582 | mstore(0x20, p0) |
| 4583 | mstore(0x40, p1) |
| 4584 | mstore(0x60, p2) |
| 4585 | mstore(0x80, 0x80) |
| 4586 | writeString(0xa0, p3) |
| 4587 | } |
| 4588 | _sendLogPayload(0x1c, 0xc4); |
| 4589 | /// @solidity memory-safe-assembly |
| 4590 | assembly { |
| 4591 | mstore(0x00, m0) |
| 4592 | mstore(0x20, m1) |
| 4593 | mstore(0x40, m2) |
| 4594 | mstore(0x60, m3) |
| 4595 | mstore(0x80, m4) |
| 4596 | mstore(0xa0, m5) |
| 4597 | mstore(0xc0, m6) |
| 4598 | } |
| 4599 | } |
| 4600 | |
| 4601 | function log(address p0, uint256 p1, bytes32 p2, address p3) internal pure { |
| 4602 | bytes32 m0; |
| 4603 | bytes32 m1; |
| 4604 | bytes32 m2; |
| 4605 | bytes32 m3; |
| 4606 | bytes32 m4; |
| 4607 | bytes32 m5; |
| 4608 | bytes32 m6; |
| 4609 | /// @solidity memory-safe-assembly |
| 4610 | assembly { |
| 4611 | function writeString(pos, w) { |
| 4612 | let length := 0 |
| 4613 | for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } |
| 4614 | mstore(pos, length) |
| 4615 | let shift := sub(256, shl(3, length)) |
| 4616 | mstore(add(pos, 0x20), shl(shift, shr(shift, w))) |
| 4617 | } |
| 4618 | m0 := mload(0x00) |
| 4619 | m1 := mload(0x20) |
| 4620 | m2 := mload(0x40) |
| 4621 | m3 := mload(0x60) |
| 4622 | m4 := mload(0x80) |
| 4623 | m5 := mload(0xa0) |
| 4624 | m6 := mload(0xc0) |
| 4625 | // Selector of `log(address,uint256,string,address)`. |
| 4626 | mstore(0x00, 0x5c430d47) |
| 4627 | mstore(0x20, p0) |
| 4628 | mstore(0x40, p1) |
| 4629 | mstore(0x60, 0x80) |
| 4630 | mstore(0x80, p3) |
| 4631 | writeString(0xa0, p2) |
| 4632 | } |
| 4633 | _sendLogPayload(0x1c, 0xc4); |
| 4634 | /// @solidity memory-safe-assembly |
| 4635 | assembly { |
| 4636 | mstore(0x00, m0) |
| 4637 | mstore(0x20, m1) |
| 4638 | mstore(0x40, m2) |
| 4639 | mstore(0x60, m3) |
| 4640 | mstore(0x80, m4) |
| 4641 | mstore(0xa0, m5) |
| 4642 | mstore(0xc0, m6) |
| 4643 | } |
| 4644 | } |
| 4645 | |
| 4646 | function log(address p0, uint256 p1, bytes32 p2, bool p3) internal pure { |
| 4647 | bytes32 m0; |
| 4648 | bytes32 m1; |
| 4649 | bytes32 m2; |
| 4650 | bytes32 m3; |
| 4651 | bytes32 m4; |
| 4652 | bytes32 m5; |
| 4653 | bytes32 m6; |
| 4654 | /// @solidity memory-safe-assembly |
| 4655 | assembly { |
| 4656 | function writeString(pos, w) { |
| 4657 | let length := 0 |
| 4658 | for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } |
| 4659 | mstore(pos, length) |
| 4660 | let shift := sub(256, shl(3, length)) |
| 4661 | mstore(add(pos, 0x20), shl(shift, shr(shift, w))) |
| 4662 | } |
| 4663 | m0 := mload(0x00) |
| 4664 | m1 := mload(0x20) |
| 4665 | m2 := mload(0x40) |
| 4666 | m3 := mload(0x60) |
| 4667 | m4 := mload(0x80) |
| 4668 | m5 := mload(0xa0) |
| 4669 | m6 := mload(0xc0) |
| 4670 | // Selector of `log(address,uint256,string,bool)`. |
| 4671 | mstore(0x00, 0xcf18105c) |
| 4672 | mstore(0x20, p0) |
| 4673 | mstore(0x40, p1) |
| 4674 | mstore(0x60, 0x80) |
| 4675 | mstore(0x80, p3) |
| 4676 | writeString(0xa0, p2) |
| 4677 | } |
| 4678 | _sendLogPayload(0x1c, 0xc4); |
| 4679 | /// @solidity memory-safe-assembly |
| 4680 | assembly { |
| 4681 | mstore(0x00, m0) |
| 4682 | mstore(0x20, m1) |
| 4683 | mstore(0x40, m2) |
| 4684 | mstore(0x60, m3) |
| 4685 | mstore(0x80, m4) |
| 4686 | mstore(0xa0, m5) |
| 4687 | mstore(0xc0, m6) |
| 4688 | } |
| 4689 | } |
| 4690 | |
| 4691 | function log(address p0, uint256 p1, bytes32 p2, uint256 p3) internal pure { |
| 4692 | bytes32 m0; |
| 4693 | bytes32 m1; |
| 4694 | bytes32 m2; |
| 4695 | bytes32 m3; |
| 4696 | bytes32 m4; |
| 4697 | bytes32 m5; |
| 4698 | bytes32 m6; |
| 4699 | /// @solidity memory-safe-assembly |
| 4700 | assembly { |
| 4701 | function writeString(pos, w) { |
| 4702 | let length := 0 |
| 4703 | for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } |
| 4704 | mstore(pos, length) |
| 4705 | let shift := sub(256, shl(3, length)) |
| 4706 | mstore(add(pos, 0x20), shl(shift, shr(shift, w))) |
| 4707 | } |
| 4708 | m0 := mload(0x00) |
| 4709 | m1 := mload(0x20) |
| 4710 | m2 := mload(0x40) |
| 4711 | m3 := mload(0x60) |
| 4712 | m4 := mload(0x80) |
| 4713 | m5 := mload(0xa0) |
| 4714 | m6 := mload(0xc0) |
| 4715 | // Selector of `log(address,uint256,string,uint256)`. |
| 4716 | mstore(0x00, 0xbf01f891) |
| 4717 | mstore(0x20, p0) |
| 4718 | mstore(0x40, p1) |
| 4719 | mstore(0x60, 0x80) |
| 4720 | mstore(0x80, p3) |
| 4721 | writeString(0xa0, p2) |
| 4722 | } |
| 4723 | _sendLogPayload(0x1c, 0xc4); |
| 4724 | /// @solidity memory-safe-assembly |
| 4725 | assembly { |
| 4726 | mstore(0x00, m0) |
| 4727 | mstore(0x20, m1) |
| 4728 | mstore(0x40, m2) |
| 4729 | mstore(0x60, m3) |
| 4730 | mstore(0x80, m4) |
| 4731 | mstore(0xa0, m5) |
| 4732 | mstore(0xc0, m6) |
| 4733 | } |
| 4734 | } |
| 4735 | |
| 4736 | function log(address p0, uint256 p1, bytes32 p2, bytes32 p3) internal pure { |
| 4737 | bytes32 m0; |
| 4738 | bytes32 m1; |
| 4739 | bytes32 m2; |
| 4740 | bytes32 m3; |
| 4741 | bytes32 m4; |
| 4742 | bytes32 m5; |
| 4743 | bytes32 m6; |
| 4744 | bytes32 m7; |
| 4745 | bytes32 m8; |
| 4746 | /// @solidity memory-safe-assembly |
| 4747 | assembly { |
| 4748 | function writeString(pos, w) { |
| 4749 | let length := 0 |
| 4750 | for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } |
| 4751 | mstore(pos, length) |
| 4752 | let shift := sub(256, shl(3, length)) |
| 4753 | mstore(add(pos, 0x20), shl(shift, shr(shift, w))) |
| 4754 | } |
| 4755 | m0 := mload(0x00) |
| 4756 | m1 := mload(0x20) |
| 4757 | m2 := mload(0x40) |
| 4758 | m3 := mload(0x60) |
| 4759 | m4 := mload(0x80) |
| 4760 | m5 := mload(0xa0) |
| 4761 | m6 := mload(0xc0) |
| 4762 | m7 := mload(0xe0) |
| 4763 | m8 := mload(0x100) |
| 4764 | // Selector of `log(address,uint256,string,string)`. |
| 4765 | mstore(0x00, 0x88a8c406) |
| 4766 | mstore(0x20, p0) |
| 4767 | mstore(0x40, p1) |
| 4768 | mstore(0x60, 0x80) |
| 4769 | mstore(0x80, 0xc0) |
| 4770 | writeString(0xa0, p2) |
| 4771 | writeString(0xe0, p3) |
| 4772 | } |
| 4773 | _sendLogPayload(0x1c, 0x104); |
| 4774 | /// @solidity memory-safe-assembly |
| 4775 | assembly { |
| 4776 | mstore(0x00, m0) |
| 4777 | mstore(0x20, m1) |
| 4778 | mstore(0x40, m2) |
| 4779 | mstore(0x60, m3) |
| 4780 | mstore(0x80, m4) |
| 4781 | mstore(0xa0, m5) |
| 4782 | mstore(0xc0, m6) |
| 4783 | mstore(0xe0, m7) |
| 4784 | mstore(0x100, m8) |
| 4785 | } |
| 4786 | } |
| 4787 | |
| 4788 | function log(address p0, bytes32 p1, address p2, address p3) internal pure { |
| 4789 | bytes32 m0; |
| 4790 | bytes32 m1; |
| 4791 | bytes32 m2; |
| 4792 | bytes32 m3; |
| 4793 | bytes32 m4; |
| 4794 | bytes32 m5; |
| 4795 | bytes32 m6; |
| 4796 | /// @solidity memory-safe-assembly |
| 4797 | assembly { |
| 4798 | function writeString(pos, w) { |
| 4799 | let length := 0 |
| 4800 | for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } |
| 4801 | mstore(pos, length) |
| 4802 | let shift := sub(256, shl(3, length)) |
| 4803 | mstore(add(pos, 0x20), shl(shift, shr(shift, w))) |
| 4804 | } |
| 4805 | m0 := mload(0x00) |
| 4806 | m1 := mload(0x20) |
| 4807 | m2 := mload(0x40) |
| 4808 | m3 := mload(0x60) |
| 4809 | m4 := mload(0x80) |
| 4810 | m5 := mload(0xa0) |
| 4811 | m6 := mload(0xc0) |
| 4812 | // Selector of `log(address,string,address,address)`. |
| 4813 | mstore(0x00, 0x0d36fa20) |
| 4814 | mstore(0x20, p0) |
| 4815 | mstore(0x40, 0x80) |
| 4816 | mstore(0x60, p2) |
| 4817 | mstore(0x80, p3) |
| 4818 | writeString(0xa0, p1) |
| 4819 | } |
| 4820 | _sendLogPayload(0x1c, 0xc4); |
| 4821 | /// @solidity memory-safe-assembly |
| 4822 | assembly { |
| 4823 | mstore(0x00, m0) |
| 4824 | mstore(0x20, m1) |
| 4825 | mstore(0x40, m2) |
| 4826 | mstore(0x60, m3) |
| 4827 | mstore(0x80, m4) |
| 4828 | mstore(0xa0, m5) |
| 4829 | mstore(0xc0, m6) |
| 4830 | } |
| 4831 | } |
| 4832 | |
| 4833 | function log(address p0, bytes32 p1, address p2, bool p3) internal pure { |
| 4834 | bytes32 m0; |
| 4835 | bytes32 m1; |
| 4836 | bytes32 m2; |
| 4837 | bytes32 m3; |
| 4838 | bytes32 m4; |
| 4839 | bytes32 m5; |
| 4840 | bytes32 m6; |
| 4841 | /// @solidity memory-safe-assembly |
| 4842 | assembly { |
| 4843 | function writeString(pos, w) { |
| 4844 | let length := 0 |
| 4845 | for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } |
| 4846 | mstore(pos, length) |
| 4847 | let shift := sub(256, shl(3, length)) |
| 4848 | mstore(add(pos, 0x20), shl(shift, shr(shift, w))) |
| 4849 | } |
| 4850 | m0 := mload(0x00) |
| 4851 | m1 := mload(0x20) |
| 4852 | m2 := mload(0x40) |
| 4853 | m3 := mload(0x60) |
| 4854 | m4 := mload(0x80) |
| 4855 | m5 := mload(0xa0) |
| 4856 | m6 := mload(0xc0) |
| 4857 | // Selector of `log(address,string,address,bool)`. |
| 4858 | mstore(0x00, 0x0df12b76) |
| 4859 | mstore(0x20, p0) |
| 4860 | mstore(0x40, 0x80) |
| 4861 | mstore(0x60, p2) |
| 4862 | mstore(0x80, p3) |
| 4863 | writeString(0xa0, p1) |
| 4864 | } |
| 4865 | _sendLogPayload(0x1c, 0xc4); |
| 4866 | /// @solidity memory-safe-assembly |
| 4867 | assembly { |
| 4868 | mstore(0x00, m0) |
| 4869 | mstore(0x20, m1) |
| 4870 | mstore(0x40, m2) |
| 4871 | mstore(0x60, m3) |
| 4872 | mstore(0x80, m4) |
| 4873 | mstore(0xa0, m5) |
| 4874 | mstore(0xc0, m6) |
| 4875 | } |
| 4876 | } |
| 4877 | |
| 4878 | function log(address p0, bytes32 p1, address p2, uint256 p3) internal pure { |
| 4879 | bytes32 m0; |
| 4880 | bytes32 m1; |
| 4881 | bytes32 m2; |
| 4882 | bytes32 m3; |
| 4883 | bytes32 m4; |
| 4884 | bytes32 m5; |
| 4885 | bytes32 m6; |
| 4886 | /// @solidity memory-safe-assembly |
| 4887 | assembly { |
| 4888 | function writeString(pos, w) { |
| 4889 | let length := 0 |
| 4890 | for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } |
| 4891 | mstore(pos, length) |
| 4892 | let shift := sub(256, shl(3, length)) |
| 4893 | mstore(add(pos, 0x20), shl(shift, shr(shift, w))) |
| 4894 | } |
| 4895 | m0 := mload(0x00) |
| 4896 | m1 := mload(0x20) |
| 4897 | m2 := mload(0x40) |
| 4898 | m3 := mload(0x60) |
| 4899 | m4 := mload(0x80) |
| 4900 | m5 := mload(0xa0) |
| 4901 | m6 := mload(0xc0) |
| 4902 | // Selector of `log(address,string,address,uint256)`. |
| 4903 | mstore(0x00, 0x457fe3cf) |
| 4904 | mstore(0x20, p0) |
| 4905 | mstore(0x40, 0x80) |
| 4906 | mstore(0x60, p2) |
| 4907 | mstore(0x80, p3) |
| 4908 | writeString(0xa0, p1) |
| 4909 | } |
| 4910 | _sendLogPayload(0x1c, 0xc4); |
| 4911 | /// @solidity memory-safe-assembly |
| 4912 | assembly { |
| 4913 | mstore(0x00, m0) |
| 4914 | mstore(0x20, m1) |
| 4915 | mstore(0x40, m2) |
| 4916 | mstore(0x60, m3) |
| 4917 | mstore(0x80, m4) |
| 4918 | mstore(0xa0, m5) |
| 4919 | mstore(0xc0, m6) |
| 4920 | } |
| 4921 | } |
| 4922 | |
| 4923 | function log(address p0, bytes32 p1, address p2, bytes32 p3) internal pure { |
| 4924 | bytes32 m0; |
| 4925 | bytes32 m1; |
| 4926 | bytes32 m2; |
| 4927 | bytes32 m3; |
| 4928 | bytes32 m4; |
| 4929 | bytes32 m5; |
| 4930 | bytes32 m6; |
| 4931 | bytes32 m7; |
| 4932 | bytes32 m8; |
| 4933 | /// @solidity memory-safe-assembly |
| 4934 | assembly { |
| 4935 | function writeString(pos, w) { |
| 4936 | let length := 0 |
| 4937 | for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } |
| 4938 | mstore(pos, length) |
| 4939 | let shift := sub(256, shl(3, length)) |
| 4940 | mstore(add(pos, 0x20), shl(shift, shr(shift, w))) |
| 4941 | } |
| 4942 | m0 := mload(0x00) |
| 4943 | m1 := mload(0x20) |
| 4944 | m2 := mload(0x40) |
| 4945 | m3 := mload(0x60) |
| 4946 | m4 := mload(0x80) |
| 4947 | m5 := mload(0xa0) |
| 4948 | m6 := mload(0xc0) |
| 4949 | m7 := mload(0xe0) |
| 4950 | m8 := mload(0x100) |
| 4951 | // Selector of `log(address,string,address,string)`. |
| 4952 | mstore(0x00, 0xf7e36245) |
| 4953 | mstore(0x20, p0) |
| 4954 | mstore(0x40, 0x80) |
| 4955 | mstore(0x60, p2) |
| 4956 | mstore(0x80, 0xc0) |
| 4957 | writeString(0xa0, p1) |
| 4958 | writeString(0xe0, p3) |
| 4959 | } |
| 4960 | _sendLogPayload(0x1c, 0x104); |
| 4961 | /// @solidity memory-safe-assembly |
| 4962 | assembly { |
| 4963 | mstore(0x00, m0) |
| 4964 | mstore(0x20, m1) |
| 4965 | mstore(0x40, m2) |
| 4966 | mstore(0x60, m3) |
| 4967 | mstore(0x80, m4) |
| 4968 | mstore(0xa0, m5) |
| 4969 | mstore(0xc0, m6) |
| 4970 | mstore(0xe0, m7) |
| 4971 | mstore(0x100, m8) |
| 4972 | } |
| 4973 | } |
| 4974 | |
| 4975 | function log(address p0, bytes32 p1, bool p2, address p3) internal pure { |
| 4976 | bytes32 m0; |
| 4977 | bytes32 m1; |
| 4978 | bytes32 m2; |
| 4979 | bytes32 m3; |
| 4980 | bytes32 m4; |
| 4981 | bytes32 m5; |
| 4982 | bytes32 m6; |
| 4983 | /// @solidity memory-safe-assembly |
| 4984 | assembly { |
| 4985 | function writeString(pos, w) { |
| 4986 | let length := 0 |
| 4987 | for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } |
| 4988 | mstore(pos, length) |
| 4989 | let shift := sub(256, shl(3, length)) |
| 4990 | mstore(add(pos, 0x20), shl(shift, shr(shift, w))) |
| 4991 | } |
| 4992 | m0 := mload(0x00) |
| 4993 | m1 := mload(0x20) |
| 4994 | m2 := mload(0x40) |
| 4995 | m3 := mload(0x60) |
| 4996 | m4 := mload(0x80) |
| 4997 | m5 := mload(0xa0) |
| 4998 | m6 := mload(0xc0) |
| 4999 | // Selector of `log(address,string,bool,address)`. |
| 5000 | mstore(0x00, 0x205871c2) |
| 5001 | mstore(0x20, p0) |
| 5002 | mstore(0x40, 0x80) |
| 5003 | mstore(0x60, p2) |
| 5004 | mstore(0x80, p3) |
| 5005 | writeString(0xa0, p1) |
| 5006 | } |
| 5007 | _sendLogPayload(0x1c, 0xc4); |
| 5008 | /// @solidity memory-safe-assembly |
| 5009 | assembly { |
| 5010 | mstore(0x00, m0) |
| 5011 | mstore(0x20, m1) |
| 5012 | mstore(0x40, m2) |
| 5013 | mstore(0x60, m3) |
| 5014 | mstore(0x80, m4) |
| 5015 | mstore(0xa0, m5) |
| 5016 | mstore(0xc0, m6) |
| 5017 | } |
| 5018 | } |
| 5019 | |
| 5020 | function log(address p0, bytes32 p1, bool p2, bool p3) internal pure { |
| 5021 | bytes32 m0; |
| 5022 | bytes32 m1; |
| 5023 | bytes32 m2; |
| 5024 | bytes32 m3; |
| 5025 | bytes32 m4; |
| 5026 | bytes32 m5; |
| 5027 | bytes32 m6; |
| 5028 | /// @solidity memory-safe-assembly |
| 5029 | assembly { |
| 5030 | function writeString(pos, w) { |
| 5031 | let length := 0 |
| 5032 | for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } |
| 5033 | mstore(pos, length) |
| 5034 | let shift := sub(256, shl(3, length)) |
| 5035 | mstore(add(pos, 0x20), shl(shift, shr(shift, w))) |
| 5036 | } |
| 5037 | m0 := mload(0x00) |
| 5038 | m1 := mload(0x20) |
| 5039 | m2 := mload(0x40) |
| 5040 | m3 := mload(0x60) |
| 5041 | m4 := mload(0x80) |
| 5042 | m5 := mload(0xa0) |
| 5043 | m6 := mload(0xc0) |
| 5044 | // Selector of `log(address,string,bool,bool)`. |
| 5045 | mstore(0x00, 0x5f1d5c9f) |
| 5046 | mstore(0x20, p0) |
| 5047 | mstore(0x40, 0x80) |
| 5048 | mstore(0x60, p2) |
| 5049 | mstore(0x80, p3) |
| 5050 | writeString(0xa0, p1) |
| 5051 | } |
| 5052 | _sendLogPayload(0x1c, 0xc4); |
| 5053 | /// @solidity memory-safe-assembly |
| 5054 | assembly { |
| 5055 | mstore(0x00, m0) |
| 5056 | mstore(0x20, m1) |
| 5057 | mstore(0x40, m2) |
| 5058 | mstore(0x60, m3) |
| 5059 | mstore(0x80, m4) |
| 5060 | mstore(0xa0, m5) |
| 5061 | mstore(0xc0, m6) |
| 5062 | } |
| 5063 | } |
| 5064 | |
| 5065 | function log(address p0, bytes32 p1, bool p2, uint256 p3) internal pure { |
| 5066 | bytes32 m0; |
| 5067 | bytes32 m1; |
| 5068 | bytes32 m2; |
| 5069 | bytes32 m3; |
| 5070 | bytes32 m4; |
| 5071 | bytes32 m5; |
| 5072 | bytes32 m6; |
| 5073 | /// @solidity memory-safe-assembly |
| 5074 | assembly { |
| 5075 | function writeString(pos, w) { |
| 5076 | let length := 0 |
| 5077 | for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } |
| 5078 | mstore(pos, length) |
| 5079 | let shift := sub(256, shl(3, length)) |
| 5080 | mstore(add(pos, 0x20), shl(shift, shr(shift, w))) |
| 5081 | } |
| 5082 | m0 := mload(0x00) |
| 5083 | m1 := mload(0x20) |
| 5084 | m2 := mload(0x40) |
| 5085 | m3 := mload(0x60) |
| 5086 | m4 := mload(0x80) |
| 5087 | m5 := mload(0xa0) |
| 5088 | m6 := mload(0xc0) |
| 5089 | // Selector of `log(address,string,bool,uint256)`. |
| 5090 | mstore(0x00, 0x515e38b6) |
| 5091 | mstore(0x20, p0) |
| 5092 | mstore(0x40, 0x80) |
| 5093 | mstore(0x60, p2) |
| 5094 | mstore(0x80, p3) |
| 5095 | writeString(0xa0, p1) |
| 5096 | } |
| 5097 | _sendLogPayload(0x1c, 0xc4); |
| 5098 | /// @solidity memory-safe-assembly |
| 5099 | assembly { |
| 5100 | mstore(0x00, m0) |
| 5101 | mstore(0x20, m1) |
| 5102 | mstore(0x40, m2) |
| 5103 | mstore(0x60, m3) |
| 5104 | mstore(0x80, m4) |
| 5105 | mstore(0xa0, m5) |
| 5106 | mstore(0xc0, m6) |
| 5107 | } |
| 5108 | } |
| 5109 | |
| 5110 | function log(address p0, bytes32 p1, bool p2, bytes32 p3) internal pure { |
| 5111 | bytes32 m0; |
| 5112 | bytes32 m1; |
| 5113 | bytes32 m2; |
| 5114 | bytes32 m3; |
| 5115 | bytes32 m4; |
| 5116 | bytes32 m5; |
| 5117 | bytes32 m6; |
| 5118 | bytes32 m7; |
| 5119 | bytes32 m8; |
| 5120 | /// @solidity memory-safe-assembly |
| 5121 | assembly { |
| 5122 | function writeString(pos, w) { |
| 5123 | let length := 0 |
| 5124 | for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } |
| 5125 | mstore(pos, length) |
| 5126 | let shift := sub(256, shl(3, length)) |
| 5127 | mstore(add(pos, 0x20), shl(shift, shr(shift, w))) |
| 5128 | } |
| 5129 | m0 := mload(0x00) |
| 5130 | m1 := mload(0x20) |
| 5131 | m2 := mload(0x40) |
| 5132 | m3 := mload(0x60) |
| 5133 | m4 := mload(0x80) |
| 5134 | m5 := mload(0xa0) |
| 5135 | m6 := mload(0xc0) |
| 5136 | m7 := mload(0xe0) |
| 5137 | m8 := mload(0x100) |
| 5138 | // Selector of `log(address,string,bool,string)`. |
| 5139 | mstore(0x00, 0xbc0b61fe) |
| 5140 | mstore(0x20, p0) |
| 5141 | mstore(0x40, 0x80) |
| 5142 | mstore(0x60, p2) |
| 5143 | mstore(0x80, 0xc0) |
| 5144 | writeString(0xa0, p1) |
| 5145 | writeString(0xe0, p3) |
| 5146 | } |
| 5147 | _sendLogPayload(0x1c, 0x104); |
| 5148 | /// @solidity memory-safe-assembly |
| 5149 | assembly { |
| 5150 | mstore(0x00, m0) |
| 5151 | mstore(0x20, m1) |
| 5152 | mstore(0x40, m2) |
| 5153 | mstore(0x60, m3) |
| 5154 | mstore(0x80, m4) |
| 5155 | mstore(0xa0, m5) |
| 5156 | mstore(0xc0, m6) |
| 5157 | mstore(0xe0, m7) |
| 5158 | mstore(0x100, m8) |
| 5159 | } |
| 5160 | } |
| 5161 | |
| 5162 | function log(address p0, bytes32 p1, uint256 p2, address p3) internal pure { |
| 5163 | bytes32 m0; |
| 5164 | bytes32 m1; |
| 5165 | bytes32 m2; |
| 5166 | bytes32 m3; |
| 5167 | bytes32 m4; |
| 5168 | bytes32 m5; |
| 5169 | bytes32 m6; |
| 5170 | /// @solidity memory-safe-assembly |
| 5171 | assembly { |
| 5172 | function writeString(pos, w) { |
| 5173 | let length := 0 |
| 5174 | for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } |
| 5175 | mstore(pos, length) |
| 5176 | let shift := sub(256, shl(3, length)) |
| 5177 | mstore(add(pos, 0x20), shl(shift, shr(shift, w))) |
| 5178 | } |
| 5179 | m0 := mload(0x00) |
| 5180 | m1 := mload(0x20) |
| 5181 | m2 := mload(0x40) |
| 5182 | m3 := mload(0x60) |
| 5183 | m4 := mload(0x80) |
| 5184 | m5 := mload(0xa0) |
| 5185 | m6 := mload(0xc0) |
| 5186 | // Selector of `log(address,string,uint256,address)`. |
| 5187 | mstore(0x00, 0x63183678) |
| 5188 | mstore(0x20, p0) |
| 5189 | mstore(0x40, 0x80) |
| 5190 | mstore(0x60, p2) |
| 5191 | mstore(0x80, p3) |
| 5192 | writeString(0xa0, p1) |
| 5193 | } |
| 5194 | _sendLogPayload(0x1c, 0xc4); |
| 5195 | /// @solidity memory-safe-assembly |
| 5196 | assembly { |
| 5197 | mstore(0x00, m0) |
| 5198 | mstore(0x20, m1) |
| 5199 | mstore(0x40, m2) |
| 5200 | mstore(0x60, m3) |
| 5201 | mstore(0x80, m4) |
| 5202 | mstore(0xa0, m5) |
| 5203 | mstore(0xc0, m6) |
| 5204 | } |
| 5205 | } |
| 5206 | |
| 5207 | function log(address p0, bytes32 p1, uint256 p2, bool p3) internal pure { |
| 5208 | bytes32 m0; |
| 5209 | bytes32 m1; |
| 5210 | bytes32 m2; |
| 5211 | bytes32 m3; |
| 5212 | bytes32 m4; |
| 5213 | bytes32 m5; |
| 5214 | bytes32 m6; |
| 5215 | /// @solidity memory-safe-assembly |
| 5216 | assembly { |
| 5217 | function writeString(pos, w) { |
| 5218 | let length := 0 |
| 5219 | for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } |
| 5220 | mstore(pos, length) |
| 5221 | let shift := sub(256, shl(3, length)) |
| 5222 | mstore(add(pos, 0x20), shl(shift, shr(shift, w))) |
| 5223 | } |
| 5224 | m0 := mload(0x00) |
| 5225 | m1 := mload(0x20) |
| 5226 | m2 := mload(0x40) |
| 5227 | m3 := mload(0x60) |
| 5228 | m4 := mload(0x80) |
| 5229 | m5 := mload(0xa0) |
| 5230 | m6 := mload(0xc0) |
| 5231 | // Selector of `log(address,string,uint256,bool)`. |
| 5232 | mstore(0x00, 0x0ef7e050) |
| 5233 | mstore(0x20, p0) |
| 5234 | mstore(0x40, 0x80) |
| 5235 | mstore(0x60, p2) |
| 5236 | mstore(0x80, p3) |
| 5237 | writeString(0xa0, p1) |
| 5238 | } |
| 5239 | _sendLogPayload(0x1c, 0xc4); |
| 5240 | /// @solidity memory-safe-assembly |
| 5241 | assembly { |
| 5242 | mstore(0x00, m0) |
| 5243 | mstore(0x20, m1) |
| 5244 | mstore(0x40, m2) |
| 5245 | mstore(0x60, m3) |
| 5246 | mstore(0x80, m4) |
| 5247 | mstore(0xa0, m5) |
| 5248 | mstore(0xc0, m6) |
| 5249 | } |
| 5250 | } |
| 5251 | |
| 5252 | function log(address p0, bytes32 p1, uint256 p2, uint256 p3) internal pure { |
| 5253 | bytes32 m0; |
| 5254 | bytes32 m1; |
| 5255 | bytes32 m2; |
| 5256 | bytes32 m3; |
| 5257 | bytes32 m4; |
| 5258 | bytes32 m5; |
| 5259 | bytes32 m6; |
| 5260 | /// @solidity memory-safe-assembly |
| 5261 | assembly { |
| 5262 | function writeString(pos, w) { |
| 5263 | let length := 0 |
| 5264 | for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } |
| 5265 | mstore(pos, length) |
| 5266 | let shift := sub(256, shl(3, length)) |
| 5267 | mstore(add(pos, 0x20), shl(shift, shr(shift, w))) |
| 5268 | } |
| 5269 | m0 := mload(0x00) |
| 5270 | m1 := mload(0x20) |
| 5271 | m2 := mload(0x40) |
| 5272 | m3 := mload(0x60) |
| 5273 | m4 := mload(0x80) |
| 5274 | m5 := mload(0xa0) |
| 5275 | m6 := mload(0xc0) |
| 5276 | // Selector of `log(address,string,uint256,uint256)`. |
| 5277 | mstore(0x00, 0x1dc8e1b8) |
| 5278 | mstore(0x20, p0) |
| 5279 | mstore(0x40, 0x80) |
| 5280 | mstore(0x60, p2) |
| 5281 | mstore(0x80, p3) |
| 5282 | writeString(0xa0, p1) |
| 5283 | } |
| 5284 | _sendLogPayload(0x1c, 0xc4); |
| 5285 | /// @solidity memory-safe-assembly |
| 5286 | assembly { |
| 5287 | mstore(0x00, m0) |
| 5288 | mstore(0x20, m1) |
| 5289 | mstore(0x40, m2) |
| 5290 | mstore(0x60, m3) |
| 5291 | mstore(0x80, m4) |
| 5292 | mstore(0xa0, m5) |
| 5293 | mstore(0xc0, m6) |
| 5294 | } |
| 5295 | } |
| 5296 | |
| 5297 | function log(address p0, bytes32 p1, uint256 p2, bytes32 p3) internal pure { |
| 5298 | bytes32 m0; |
| 5299 | bytes32 m1; |
| 5300 | bytes32 m2; |
| 5301 | bytes32 m3; |
| 5302 | bytes32 m4; |
| 5303 | bytes32 m5; |
| 5304 | bytes32 m6; |
| 5305 | bytes32 m7; |
| 5306 | bytes32 m8; |
| 5307 | /// @solidity memory-safe-assembly |
| 5308 | assembly { |
| 5309 | function writeString(pos, w) { |
| 5310 | let length := 0 |
| 5311 | for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } |
| 5312 | mstore(pos, length) |
| 5313 | let shift := sub(256, shl(3, length)) |
| 5314 | mstore(add(pos, 0x20), shl(shift, shr(shift, w))) |
| 5315 | } |
| 5316 | m0 := mload(0x00) |
| 5317 | m1 := mload(0x20) |
| 5318 | m2 := mload(0x40) |
| 5319 | m3 := mload(0x60) |
| 5320 | m4 := mload(0x80) |
| 5321 | m5 := mload(0xa0) |
| 5322 | m6 := mload(0xc0) |
| 5323 | m7 := mload(0xe0) |
| 5324 | m8 := mload(0x100) |
| 5325 | // Selector of `log(address,string,uint256,string)`. |
| 5326 | mstore(0x00, 0x448830a8) |
| 5327 | mstore(0x20, p0) |
| 5328 | mstore(0x40, 0x80) |
| 5329 | mstore(0x60, p2) |
| 5330 | mstore(0x80, 0xc0) |
| 5331 | writeString(0xa0, p1) |
| 5332 | writeString(0xe0, p3) |
| 5333 | } |
| 5334 | _sendLogPayload(0x1c, 0x104); |
| 5335 | /// @solidity memory-safe-assembly |
| 5336 | assembly { |
| 5337 | mstore(0x00, m0) |
| 5338 | mstore(0x20, m1) |
| 5339 | mstore(0x40, m2) |
| 5340 | mstore(0x60, m3) |
| 5341 | mstore(0x80, m4) |
| 5342 | mstore(0xa0, m5) |
| 5343 | mstore(0xc0, m6) |
| 5344 | mstore(0xe0, m7) |
| 5345 | mstore(0x100, m8) |
| 5346 | } |
| 5347 | } |
| 5348 | |
| 5349 | function log(address p0, bytes32 p1, bytes32 p2, address p3) internal pure { |
| 5350 | bytes32 m0; |
| 5351 | bytes32 m1; |
| 5352 | bytes32 m2; |
| 5353 | bytes32 m3; |
| 5354 | bytes32 m4; |
| 5355 | bytes32 m5; |
| 5356 | bytes32 m6; |
| 5357 | bytes32 m7; |
| 5358 | bytes32 m8; |
| 5359 | /// @solidity memory-safe-assembly |
| 5360 | assembly { |
| 5361 | function writeString(pos, w) { |
| 5362 | let length := 0 |
| 5363 | for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } |
| 5364 | mstore(pos, length) |
| 5365 | let shift := sub(256, shl(3, length)) |
| 5366 | mstore(add(pos, 0x20), shl(shift, shr(shift, w))) |
| 5367 | } |
| 5368 | m0 := mload(0x00) |
| 5369 | m1 := mload(0x20) |
| 5370 | m2 := mload(0x40) |
| 5371 | m3 := mload(0x60) |
| 5372 | m4 := mload(0x80) |
| 5373 | m5 := mload(0xa0) |
| 5374 | m6 := mload(0xc0) |
| 5375 | m7 := mload(0xe0) |
| 5376 | m8 := mload(0x100) |
| 5377 | // Selector of `log(address,string,string,address)`. |
| 5378 | mstore(0x00, 0xa04e2f87) |
| 5379 | mstore(0x20, p0) |
| 5380 | mstore(0x40, 0x80) |
| 5381 | mstore(0x60, 0xc0) |
| 5382 | mstore(0x80, p3) |
| 5383 | writeString(0xa0, p1) |
| 5384 | writeString(0xe0, p2) |
| 5385 | } |
| 5386 | _sendLogPayload(0x1c, 0x104); |
| 5387 | /// @solidity memory-safe-assembly |
| 5388 | assembly { |
| 5389 | mstore(0x00, m0) |
| 5390 | mstore(0x20, m1) |
| 5391 | mstore(0x40, m2) |
| 5392 | mstore(0x60, m3) |
| 5393 | mstore(0x80, m4) |
| 5394 | mstore(0xa0, m5) |
| 5395 | mstore(0xc0, m6) |
| 5396 | mstore(0xe0, m7) |
| 5397 | mstore(0x100, m8) |
| 5398 | } |
| 5399 | } |
| 5400 | |
| 5401 | function log(address p0, bytes32 p1, bytes32 p2, bool p3) internal pure { |
| 5402 | bytes32 m0; |
| 5403 | bytes32 m1; |
| 5404 | bytes32 m2; |
| 5405 | bytes32 m3; |
| 5406 | bytes32 m4; |
| 5407 | bytes32 m5; |
| 5408 | bytes32 m6; |
| 5409 | bytes32 m7; |
| 5410 | bytes32 m8; |
| 5411 | /// @solidity memory-safe-assembly |
| 5412 | assembly { |
| 5413 | function writeString(pos, w) { |
| 5414 | let length := 0 |
| 5415 | for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } |
| 5416 | mstore(pos, length) |
| 5417 | let shift := sub(256, shl(3, length)) |
| 5418 | mstore(add(pos, 0x20), shl(shift, shr(shift, w))) |
| 5419 | } |
| 5420 | m0 := mload(0x00) |
| 5421 | m1 := mload(0x20) |
| 5422 | m2 := mload(0x40) |
| 5423 | m3 := mload(0x60) |
| 5424 | m4 := mload(0x80) |
| 5425 | m5 := mload(0xa0) |
| 5426 | m6 := mload(0xc0) |
| 5427 | m7 := mload(0xe0) |
| 5428 | m8 := mload(0x100) |
| 5429 | // Selector of `log(address,string,string,bool)`. |
| 5430 | mstore(0x00, 0x35a5071f) |
| 5431 | mstore(0x20, p0) |
| 5432 | mstore(0x40, 0x80) |
| 5433 | mstore(0x60, 0xc0) |
| 5434 | mstore(0x80, p3) |
| 5435 | writeString(0xa0, p1) |
| 5436 | writeString(0xe0, p2) |
| 5437 | } |
| 5438 | _sendLogPayload(0x1c, 0x104); |
| 5439 | /// @solidity memory-safe-assembly |
| 5440 | assembly { |
| 5441 | mstore(0x00, m0) |
| 5442 | mstore(0x20, m1) |
| 5443 | mstore(0x40, m2) |
| 5444 | mstore(0x60, m3) |
| 5445 | mstore(0x80, m4) |
| 5446 | mstore(0xa0, m5) |
| 5447 | mstore(0xc0, m6) |
| 5448 | mstore(0xe0, m7) |
| 5449 | mstore(0x100, m8) |
| 5450 | } |
| 5451 | } |
| 5452 | |
| 5453 | function log(address p0, bytes32 p1, bytes32 p2, uint256 p3) internal pure { |
| 5454 | bytes32 m0; |
| 5455 | bytes32 m1; |
| 5456 | bytes32 m2; |
| 5457 | bytes32 m3; |
| 5458 | bytes32 m4; |
| 5459 | bytes32 m5; |
| 5460 | bytes32 m6; |
| 5461 | bytes32 m7; |
| 5462 | bytes32 m8; |
| 5463 | /// @solidity memory-safe-assembly |
| 5464 | assembly { |
| 5465 | function writeString(pos, w) { |
| 5466 | let length := 0 |
| 5467 | for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } |
| 5468 | mstore(pos, length) |
| 5469 | let shift := sub(256, shl(3, length)) |
| 5470 | mstore(add(pos, 0x20), shl(shift, shr(shift, w))) |
| 5471 | } |
| 5472 | m0 := mload(0x00) |
| 5473 | m1 := mload(0x20) |
| 5474 | m2 := mload(0x40) |
| 5475 | m3 := mload(0x60) |
| 5476 | m4 := mload(0x80) |
| 5477 | m5 := mload(0xa0) |
| 5478 | m6 := mload(0xc0) |
| 5479 | m7 := mload(0xe0) |
| 5480 | m8 := mload(0x100) |
| 5481 | // Selector of `log(address,string,string,uint256)`. |
| 5482 | mstore(0x00, 0x159f8927) |
| 5483 | mstore(0x20, p0) |
| 5484 | mstore(0x40, 0x80) |
| 5485 | mstore(0x60, 0xc0) |
| 5486 | mstore(0x80, p3) |
| 5487 | writeString(0xa0, p1) |
| 5488 | writeString(0xe0, p2) |
| 5489 | } |
| 5490 | _sendLogPayload(0x1c, 0x104); |
| 5491 | /// @solidity memory-safe-assembly |
| 5492 | assembly { |
| 5493 | mstore(0x00, m0) |
| 5494 | mstore(0x20, m1) |
| 5495 | mstore(0x40, m2) |
| 5496 | mstore(0x60, m3) |
| 5497 | mstore(0x80, m4) |
| 5498 | mstore(0xa0, m5) |
| 5499 | mstore(0xc0, m6) |
| 5500 | mstore(0xe0, m7) |
| 5501 | mstore(0x100, m8) |
| 5502 | } |
| 5503 | } |
| 5504 | |
| 5505 | function log(address p0, bytes32 p1, bytes32 p2, bytes32 p3) internal pure { |
| 5506 | bytes32 m0; |
| 5507 | bytes32 m1; |
| 5508 | bytes32 m2; |
| 5509 | bytes32 m3; |
| 5510 | bytes32 m4; |
| 5511 | bytes32 m5; |
| 5512 | bytes32 m6; |
| 5513 | bytes32 m7; |
| 5514 | bytes32 m8; |
| 5515 | bytes32 m9; |
| 5516 | bytes32 m10; |
| 5517 | /// @solidity memory-safe-assembly |
| 5518 | assembly { |
| 5519 | function writeString(pos, w) { |
| 5520 | let length := 0 |
| 5521 | for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } |
| 5522 | mstore(pos, length) |
| 5523 | let shift := sub(256, shl(3, length)) |
| 5524 | mstore(add(pos, 0x20), shl(shift, shr(shift, w))) |
| 5525 | } |
| 5526 | m0 := mload(0x00) |
| 5527 | m1 := mload(0x20) |
| 5528 | m2 := mload(0x40) |
| 5529 | m3 := mload(0x60) |
| 5530 | m4 := mload(0x80) |
| 5531 | m5 := mload(0xa0) |
| 5532 | m6 := mload(0xc0) |
| 5533 | m7 := mload(0xe0) |
| 5534 | m8 := mload(0x100) |
| 5535 | m9 := mload(0x120) |
| 5536 | m10 := mload(0x140) |
| 5537 | // Selector of `log(address,string,string,string)`. |
| 5538 | mstore(0x00, 0x5d02c50b) |
| 5539 | mstore(0x20, p0) |
| 5540 | mstore(0x40, 0x80) |
| 5541 | mstore(0x60, 0xc0) |
| 5542 | mstore(0x80, 0x100) |
| 5543 | writeString(0xa0, p1) |
| 5544 | writeString(0xe0, p2) |
| 5545 | writeString(0x120, p3) |
| 5546 | } |
| 5547 | _sendLogPayload(0x1c, 0x144); |
| 5548 | /// @solidity memory-safe-assembly |
| 5549 | assembly { |
| 5550 | mstore(0x00, m0) |
| 5551 | mstore(0x20, m1) |
| 5552 | mstore(0x40, m2) |
| 5553 | mstore(0x60, m3) |
| 5554 | mstore(0x80, m4) |
| 5555 | mstore(0xa0, m5) |
| 5556 | mstore(0xc0, m6) |
| 5557 | mstore(0xe0, m7) |
| 5558 | mstore(0x100, m8) |
| 5559 | mstore(0x120, m9) |
| 5560 | mstore(0x140, m10) |
| 5561 | } |
| 5562 | } |
| 5563 | |
| 5564 | function log(bool p0, address p1, address p2, address p3) internal pure { |
| 5565 | bytes32 m0; |
| 5566 | bytes32 m1; |
| 5567 | bytes32 m2; |
| 5568 | bytes32 m3; |
| 5569 | bytes32 m4; |
| 5570 | /// @solidity memory-safe-assembly |
| 5571 | assembly { |
| 5572 | m0 := mload(0x00) |
| 5573 | m1 := mload(0x20) |
| 5574 | m2 := mload(0x40) |
| 5575 | m3 := mload(0x60) |
| 5576 | m4 := mload(0x80) |
| 5577 | // Selector of `log(bool,address,address,address)`. |
| 5578 | mstore(0x00, 0x1d14d001) |
| 5579 | mstore(0x20, p0) |
| 5580 | mstore(0x40, p1) |
| 5581 | mstore(0x60, p2) |
| 5582 | mstore(0x80, p3) |
| 5583 | } |
| 5584 | _sendLogPayload(0x1c, 0x84); |
| 5585 | /// @solidity memory-safe-assembly |
| 5586 | assembly { |
| 5587 | mstore(0x00, m0) |
| 5588 | mstore(0x20, m1) |
| 5589 | mstore(0x40, m2) |
| 5590 | mstore(0x60, m3) |
| 5591 | mstore(0x80, m4) |
| 5592 | } |
| 5593 | } |
| 5594 | |
| 5595 | function log(bool p0, address p1, address p2, bool p3) internal pure { |
| 5596 | bytes32 m0; |
| 5597 | bytes32 m1; |
| 5598 | bytes32 m2; |
| 5599 | bytes32 m3; |
| 5600 | bytes32 m4; |
| 5601 | /// @solidity memory-safe-assembly |
| 5602 | assembly { |
| 5603 | m0 := mload(0x00) |
| 5604 | m1 := mload(0x20) |
| 5605 | m2 := mload(0x40) |
| 5606 | m3 := mload(0x60) |
| 5607 | m4 := mload(0x80) |
| 5608 | // Selector of `log(bool,address,address,bool)`. |
| 5609 | mstore(0x00, 0x46600be0) |
| 5610 | mstore(0x20, p0) |
| 5611 | mstore(0x40, p1) |
| 5612 | mstore(0x60, p2) |
| 5613 | mstore(0x80, p3) |
| 5614 | } |
| 5615 | _sendLogPayload(0x1c, 0x84); |
| 5616 | /// @solidity memory-safe-assembly |
| 5617 | assembly { |
| 5618 | mstore(0x00, m0) |
| 5619 | mstore(0x20, m1) |
| 5620 | mstore(0x40, m2) |
| 5621 | mstore(0x60, m3) |
| 5622 | mstore(0x80, m4) |
| 5623 | } |
| 5624 | } |
| 5625 | |
| 5626 | function log(bool p0, address p1, address p2, uint256 p3) internal pure { |
| 5627 | bytes32 m0; |
| 5628 | bytes32 m1; |
| 5629 | bytes32 m2; |
| 5630 | bytes32 m3; |
| 5631 | bytes32 m4; |
| 5632 | /// @solidity memory-safe-assembly |
| 5633 | assembly { |
| 5634 | m0 := mload(0x00) |
| 5635 | m1 := mload(0x20) |
| 5636 | m2 := mload(0x40) |
| 5637 | m3 := mload(0x60) |
| 5638 | m4 := mload(0x80) |
| 5639 | // Selector of `log(bool,address,address,uint256)`. |
| 5640 | mstore(0x00, 0x0c66d1be) |
| 5641 | mstore(0x20, p0) |
| 5642 | mstore(0x40, p1) |
| 5643 | mstore(0x60, p2) |
| 5644 | mstore(0x80, p3) |
| 5645 | } |
| 5646 | _sendLogPayload(0x1c, 0x84); |
| 5647 | /// @solidity memory-safe-assembly |
| 5648 | assembly { |
| 5649 | mstore(0x00, m0) |
| 5650 | mstore(0x20, m1) |
| 5651 | mstore(0x40, m2) |
| 5652 | mstore(0x60, m3) |
| 5653 | mstore(0x80, m4) |
| 5654 | } |
| 5655 | } |
| 5656 | |
| 5657 | function log(bool p0, address p1, address p2, bytes32 p3) internal pure { |
| 5658 | bytes32 m0; |
| 5659 | bytes32 m1; |
| 5660 | bytes32 m2; |
| 5661 | bytes32 m3; |
| 5662 | bytes32 m4; |
| 5663 | bytes32 m5; |
| 5664 | bytes32 m6; |
| 5665 | /// @solidity memory-safe-assembly |
| 5666 | assembly { |
| 5667 | function writeString(pos, w) { |
| 5668 | let length := 0 |
| 5669 | for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } |
| 5670 | mstore(pos, length) |
| 5671 | let shift := sub(256, shl(3, length)) |
| 5672 | mstore(add(pos, 0x20), shl(shift, shr(shift, w))) |
| 5673 | } |
| 5674 | m0 := mload(0x00) |
| 5675 | m1 := mload(0x20) |
| 5676 | m2 := mload(0x40) |
| 5677 | m3 := mload(0x60) |
| 5678 | m4 := mload(0x80) |
| 5679 | m5 := mload(0xa0) |
| 5680 | m6 := mload(0xc0) |
| 5681 | // Selector of `log(bool,address,address,string)`. |
| 5682 | mstore(0x00, 0xd812a167) |
| 5683 | mstore(0x20, p0) |
| 5684 | mstore(0x40, p1) |
| 5685 | mstore(0x60, p2) |
| 5686 | mstore(0x80, 0x80) |
| 5687 | writeString(0xa0, p3) |
| 5688 | } |
| 5689 | _sendLogPayload(0x1c, 0xc4); |
| 5690 | /// @solidity memory-safe-assembly |
| 5691 | assembly { |
| 5692 | mstore(0x00, m0) |
| 5693 | mstore(0x20, m1) |
| 5694 | mstore(0x40, m2) |
| 5695 | mstore(0x60, m3) |
| 5696 | mstore(0x80, m4) |
| 5697 | mstore(0xa0, m5) |
| 5698 | mstore(0xc0, m6) |
| 5699 | } |
| 5700 | } |
| 5701 | |
| 5702 | function log(bool p0, address p1, bool p2, address p3) internal pure { |
| 5703 | bytes32 m0; |
| 5704 | bytes32 m1; |
| 5705 | bytes32 m2; |
| 5706 | bytes32 m3; |
| 5707 | bytes32 m4; |
| 5708 | /// @solidity memory-safe-assembly |
| 5709 | assembly { |
| 5710 | m0 := mload(0x00) |
| 5711 | m1 := mload(0x20) |
| 5712 | m2 := mload(0x40) |
| 5713 | m3 := mload(0x60) |
| 5714 | m4 := mload(0x80) |
| 5715 | // Selector of `log(bool,address,bool,address)`. |
| 5716 | mstore(0x00, 0x1c41a336) |
| 5717 | mstore(0x20, p0) |
| 5718 | mstore(0x40, p1) |
| 5719 | mstore(0x60, p2) |
| 5720 | mstore(0x80, p3) |
| 5721 | } |
| 5722 | _sendLogPayload(0x1c, 0x84); |
| 5723 | /// @solidity memory-safe-assembly |
| 5724 | assembly { |
| 5725 | mstore(0x00, m0) |
| 5726 | mstore(0x20, m1) |
| 5727 | mstore(0x40, m2) |
| 5728 | mstore(0x60, m3) |
| 5729 | mstore(0x80, m4) |
| 5730 | } |
| 5731 | } |
| 5732 | |
| 5733 | function log(bool p0, address p1, bool p2, bool p3) internal pure { |
| 5734 | bytes32 m0; |
| 5735 | bytes32 m1; |
| 5736 | bytes32 m2; |
| 5737 | bytes32 m3; |
| 5738 | bytes32 m4; |
| 5739 | /// @solidity memory-safe-assembly |
| 5740 | assembly { |
| 5741 | m0 := mload(0x00) |
| 5742 | m1 := mload(0x20) |
| 5743 | m2 := mload(0x40) |
| 5744 | m3 := mload(0x60) |
| 5745 | m4 := mload(0x80) |
| 5746 | // Selector of `log(bool,address,bool,bool)`. |
| 5747 | mstore(0x00, 0x6a9c478b) |
| 5748 | mstore(0x20, p0) |
| 5749 | mstore(0x40, p1) |
| 5750 | mstore(0x60, p2) |
| 5751 | mstore(0x80, p3) |
| 5752 | } |
| 5753 | _sendLogPayload(0x1c, 0x84); |
| 5754 | /// @solidity memory-safe-assembly |
| 5755 | assembly { |
| 5756 | mstore(0x00, m0) |
| 5757 | mstore(0x20, m1) |
| 5758 | mstore(0x40, m2) |
| 5759 | mstore(0x60, m3) |
| 5760 | mstore(0x80, m4) |
| 5761 | } |
| 5762 | } |
| 5763 | |
| 5764 | function log(bool p0, address p1, bool p2, uint256 p3) internal pure { |
| 5765 | bytes32 m0; |
| 5766 | bytes32 m1; |
| 5767 | bytes32 m2; |
| 5768 | bytes32 m3; |
| 5769 | bytes32 m4; |
| 5770 | /// @solidity memory-safe-assembly |
| 5771 | assembly { |
| 5772 | m0 := mload(0x00) |
| 5773 | m1 := mload(0x20) |
| 5774 | m2 := mload(0x40) |
| 5775 | m3 := mload(0x60) |
| 5776 | m4 := mload(0x80) |
| 5777 | // Selector of `log(bool,address,bool,uint256)`. |
| 5778 | mstore(0x00, 0x07831502) |
| 5779 | mstore(0x20, p0) |
| 5780 | mstore(0x40, p1) |
| 5781 | mstore(0x60, p2) |
| 5782 | mstore(0x80, p3) |
| 5783 | } |
| 5784 | _sendLogPayload(0x1c, 0x84); |
| 5785 | /// @solidity memory-safe-assembly |
| 5786 | assembly { |
| 5787 | mstore(0x00, m0) |
| 5788 | mstore(0x20, m1) |
| 5789 | mstore(0x40, m2) |
| 5790 | mstore(0x60, m3) |
| 5791 | mstore(0x80, m4) |
| 5792 | } |
| 5793 | } |
| 5794 | |
| 5795 | function log(bool p0, address p1, bool p2, bytes32 p3) internal pure { |
| 5796 | bytes32 m0; |
| 5797 | bytes32 m1; |
| 5798 | bytes32 m2; |
| 5799 | bytes32 m3; |
| 5800 | bytes32 m4; |
| 5801 | bytes32 m5; |
| 5802 | bytes32 m6; |
| 5803 | /// @solidity memory-safe-assembly |
| 5804 | assembly { |
| 5805 | function writeString(pos, w) { |
| 5806 | let length := 0 |
| 5807 | for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } |
| 5808 | mstore(pos, length) |
| 5809 | let shift := sub(256, shl(3, length)) |
| 5810 | mstore(add(pos, 0x20), shl(shift, shr(shift, w))) |
| 5811 | } |
| 5812 | m0 := mload(0x00) |
| 5813 | m1 := mload(0x20) |
| 5814 | m2 := mload(0x40) |
| 5815 | m3 := mload(0x60) |
| 5816 | m4 := mload(0x80) |
| 5817 | m5 := mload(0xa0) |
| 5818 | m6 := mload(0xc0) |
| 5819 | // Selector of `log(bool,address,bool,string)`. |
| 5820 | mstore(0x00, 0x4a66cb34) |
| 5821 | mstore(0x20, p0) |
| 5822 | mstore(0x40, p1) |
| 5823 | mstore(0x60, p2) |
| 5824 | mstore(0x80, 0x80) |
| 5825 | writeString(0xa0, p3) |
| 5826 | } |
| 5827 | _sendLogPayload(0x1c, 0xc4); |
| 5828 | /// @solidity memory-safe-assembly |
| 5829 | assembly { |
| 5830 | mstore(0x00, m0) |
| 5831 | mstore(0x20, m1) |
| 5832 | mstore(0x40, m2) |
| 5833 | mstore(0x60, m3) |
| 5834 | mstore(0x80, m4) |
| 5835 | mstore(0xa0, m5) |
| 5836 | mstore(0xc0, m6) |
| 5837 | } |
| 5838 | } |
| 5839 | |
| 5840 | function log(bool p0, address p1, uint256 p2, address p3) internal pure { |
| 5841 | bytes32 m0; |
| 5842 | bytes32 m1; |
| 5843 | bytes32 m2; |
| 5844 | bytes32 m3; |
| 5845 | bytes32 m4; |
| 5846 | /// @solidity memory-safe-assembly |
| 5847 | assembly { |
| 5848 | m0 := mload(0x00) |
| 5849 | m1 := mload(0x20) |
| 5850 | m2 := mload(0x40) |
| 5851 | m3 := mload(0x60) |
| 5852 | m4 := mload(0x80) |
| 5853 | // Selector of `log(bool,address,uint256,address)`. |
| 5854 | mstore(0x00, 0x136b05dd) |
| 5855 | mstore(0x20, p0) |
| 5856 | mstore(0x40, p1) |
| 5857 | mstore(0x60, p2) |
| 5858 | mstore(0x80, p3) |
| 5859 | } |
| 5860 | _sendLogPayload(0x1c, 0x84); |
| 5861 | /// @solidity memory-safe-assembly |
| 5862 | assembly { |
| 5863 | mstore(0x00, m0) |
| 5864 | mstore(0x20, m1) |
| 5865 | mstore(0x40, m2) |
| 5866 | mstore(0x60, m3) |
| 5867 | mstore(0x80, m4) |
| 5868 | } |
| 5869 | } |
| 5870 | |
| 5871 | function log(bool p0, address p1, uint256 p2, bool p3) internal pure { |
| 5872 | bytes32 m0; |
| 5873 | bytes32 m1; |
| 5874 | bytes32 m2; |
| 5875 | bytes32 m3; |
| 5876 | bytes32 m4; |
| 5877 | /// @solidity memory-safe-assembly |
| 5878 | assembly { |
| 5879 | m0 := mload(0x00) |
| 5880 | m1 := mload(0x20) |
| 5881 | m2 := mload(0x40) |
| 5882 | m3 := mload(0x60) |
| 5883 | m4 := mload(0x80) |
| 5884 | // Selector of `log(bool,address,uint256,bool)`. |
| 5885 | mstore(0x00, 0xd6019f1c) |
| 5886 | mstore(0x20, p0) |
| 5887 | mstore(0x40, p1) |
| 5888 | mstore(0x60, p2) |
| 5889 | mstore(0x80, p3) |
| 5890 | } |
| 5891 | _sendLogPayload(0x1c, 0x84); |
| 5892 | /// @solidity memory-safe-assembly |
| 5893 | assembly { |
| 5894 | mstore(0x00, m0) |
| 5895 | mstore(0x20, m1) |
| 5896 | mstore(0x40, m2) |
| 5897 | mstore(0x60, m3) |
| 5898 | mstore(0x80, m4) |
| 5899 | } |
| 5900 | } |
| 5901 | |
| 5902 | function log(bool p0, address p1, uint256 p2, uint256 p3) internal pure { |
| 5903 | bytes32 m0; |
| 5904 | bytes32 m1; |
| 5905 | bytes32 m2; |
| 5906 | bytes32 m3; |
| 5907 | bytes32 m4; |
| 5908 | /// @solidity memory-safe-assembly |
| 5909 | assembly { |
| 5910 | m0 := mload(0x00) |
| 5911 | m1 := mload(0x20) |
| 5912 | m2 := mload(0x40) |
| 5913 | m3 := mload(0x60) |
| 5914 | m4 := mload(0x80) |
| 5915 | // Selector of `log(bool,address,uint256,uint256)`. |
| 5916 | mstore(0x00, 0x7bf181a1) |
| 5917 | mstore(0x20, p0) |
| 5918 | mstore(0x40, p1) |
| 5919 | mstore(0x60, p2) |
| 5920 | mstore(0x80, p3) |
| 5921 | } |
| 5922 | _sendLogPayload(0x1c, 0x84); |
| 5923 | /// @solidity memory-safe-assembly |
| 5924 | assembly { |
| 5925 | mstore(0x00, m0) |
| 5926 | mstore(0x20, m1) |
| 5927 | mstore(0x40, m2) |
| 5928 | mstore(0x60, m3) |
| 5929 | mstore(0x80, m4) |
| 5930 | } |
| 5931 | } |
| 5932 | |
| 5933 | function log(bool p0, address p1, uint256 p2, bytes32 p3) internal pure { |
| 5934 | bytes32 m0; |
| 5935 | bytes32 m1; |
| 5936 | bytes32 m2; |
| 5937 | bytes32 m3; |
| 5938 | bytes32 m4; |
| 5939 | bytes32 m5; |
| 5940 | bytes32 m6; |
| 5941 | /// @solidity memory-safe-assembly |
| 5942 | assembly { |
| 5943 | function writeString(pos, w) { |
| 5944 | let length := 0 |
| 5945 | for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } |
| 5946 | mstore(pos, length) |
| 5947 | let shift := sub(256, shl(3, length)) |
| 5948 | mstore(add(pos, 0x20), shl(shift, shr(shift, w))) |
| 5949 | } |
| 5950 | m0 := mload(0x00) |
| 5951 | m1 := mload(0x20) |
| 5952 | m2 := mload(0x40) |
| 5953 | m3 := mload(0x60) |
| 5954 | m4 := mload(0x80) |
| 5955 | m5 := mload(0xa0) |
| 5956 | m6 := mload(0xc0) |
| 5957 | // Selector of `log(bool,address,uint256,string)`. |
| 5958 | mstore(0x00, 0x51f09ff8) |
| 5959 | mstore(0x20, p0) |
| 5960 | mstore(0x40, p1) |
| 5961 | mstore(0x60, p2) |
| 5962 | mstore(0x80, 0x80) |
| 5963 | writeString(0xa0, p3) |
| 5964 | } |
| 5965 | _sendLogPayload(0x1c, 0xc4); |
| 5966 | /// @solidity memory-safe-assembly |
| 5967 | assembly { |
| 5968 | mstore(0x00, m0) |
| 5969 | mstore(0x20, m1) |
| 5970 | mstore(0x40, m2) |
| 5971 | mstore(0x60, m3) |
| 5972 | mstore(0x80, m4) |
| 5973 | mstore(0xa0, m5) |
| 5974 | mstore(0xc0, m6) |
| 5975 | } |
| 5976 | } |
| 5977 | |
| 5978 | function log(bool p0, address p1, bytes32 p2, address p3) internal pure { |
| 5979 | bytes32 m0; |
| 5980 | bytes32 m1; |
| 5981 | bytes32 m2; |
| 5982 | bytes32 m3; |
| 5983 | bytes32 m4; |
| 5984 | bytes32 m5; |
| 5985 | bytes32 m6; |
| 5986 | /// @solidity memory-safe-assembly |
| 5987 | assembly { |
| 5988 | function writeString(pos, w) { |
| 5989 | let length := 0 |
| 5990 | for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } |
| 5991 | mstore(pos, length) |
| 5992 | let shift := sub(256, shl(3, length)) |
| 5993 | mstore(add(pos, 0x20), shl(shift, shr(shift, w))) |
| 5994 | } |
| 5995 | m0 := mload(0x00) |
| 5996 | m1 := mload(0x20) |
| 5997 | m2 := mload(0x40) |
| 5998 | m3 := mload(0x60) |
| 5999 | m4 := mload(0x80) |
| 6000 | m5 := mload(0xa0) |
| 6001 | m6 := mload(0xc0) |
| 6002 | // Selector of `log(bool,address,string,address)`. |
| 6003 | mstore(0x00, 0x6f7c603e) |
| 6004 | mstore(0x20, p0) |
| 6005 | mstore(0x40, p1) |
| 6006 | mstore(0x60, 0x80) |
| 6007 | mstore(0x80, p3) |
| 6008 | writeString(0xa0, p2) |
| 6009 | } |
| 6010 | _sendLogPayload(0x1c, 0xc4); |
| 6011 | /// @solidity memory-safe-assembly |
| 6012 | assembly { |
| 6013 | mstore(0x00, m0) |
| 6014 | mstore(0x20, m1) |
| 6015 | mstore(0x40, m2) |
| 6016 | mstore(0x60, m3) |
| 6017 | mstore(0x80, m4) |
| 6018 | mstore(0xa0, m5) |
| 6019 | mstore(0xc0, m6) |
| 6020 | } |
| 6021 | } |
| 6022 | |
| 6023 | function log(bool p0, address p1, bytes32 p2, bool p3) internal pure { |
| 6024 | bytes32 m0; |
| 6025 | bytes32 m1; |
| 6026 | bytes32 m2; |
| 6027 | bytes32 m3; |
| 6028 | bytes32 m4; |
| 6029 | bytes32 m5; |
| 6030 | bytes32 m6; |
| 6031 | /// @solidity memory-safe-assembly |
| 6032 | assembly { |
| 6033 | function writeString(pos, w) { |
| 6034 | let length := 0 |
| 6035 | for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } |
| 6036 | mstore(pos, length) |
| 6037 | let shift := sub(256, shl(3, length)) |
| 6038 | mstore(add(pos, 0x20), shl(shift, shr(shift, w))) |
| 6039 | } |
| 6040 | m0 := mload(0x00) |
| 6041 | m1 := mload(0x20) |
| 6042 | m2 := mload(0x40) |
| 6043 | m3 := mload(0x60) |
| 6044 | m4 := mload(0x80) |
| 6045 | m5 := mload(0xa0) |
| 6046 | m6 := mload(0xc0) |
| 6047 | // Selector of `log(bool,address,string,bool)`. |
| 6048 | mstore(0x00, 0xe2bfd60b) |
| 6049 | mstore(0x20, p0) |
| 6050 | mstore(0x40, p1) |
| 6051 | mstore(0x60, 0x80) |
| 6052 | mstore(0x80, p3) |
| 6053 | writeString(0xa0, p2) |
| 6054 | } |
| 6055 | _sendLogPayload(0x1c, 0xc4); |
| 6056 | /// @solidity memory-safe-assembly |
| 6057 | assembly { |
| 6058 | mstore(0x00, m0) |
| 6059 | mstore(0x20, m1) |
| 6060 | mstore(0x40, m2) |
| 6061 | mstore(0x60, m3) |
| 6062 | mstore(0x80, m4) |
| 6063 | mstore(0xa0, m5) |
| 6064 | mstore(0xc0, m6) |
| 6065 | } |
| 6066 | } |
| 6067 | |
| 6068 | function log(bool p0, address p1, bytes32 p2, uint256 p3) internal pure { |
| 6069 | bytes32 m0; |
| 6070 | bytes32 m1; |
| 6071 | bytes32 m2; |
| 6072 | bytes32 m3; |
| 6073 | bytes32 m4; |
| 6074 | bytes32 m5; |
| 6075 | bytes32 m6; |
| 6076 | /// @solidity memory-safe-assembly |
| 6077 | assembly { |
| 6078 | function writeString(pos, w) { |
| 6079 | let length := 0 |
| 6080 | for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } |
| 6081 | mstore(pos, length) |
| 6082 | let shift := sub(256, shl(3, length)) |
| 6083 | mstore(add(pos, 0x20), shl(shift, shr(shift, w))) |
| 6084 | } |
| 6085 | m0 := mload(0x00) |
| 6086 | m1 := mload(0x20) |
| 6087 | m2 := mload(0x40) |
| 6088 | m3 := mload(0x60) |
| 6089 | m4 := mload(0x80) |
| 6090 | m5 := mload(0xa0) |
| 6091 | m6 := mload(0xc0) |
| 6092 | // Selector of `log(bool,address,string,uint256)`. |
| 6093 | mstore(0x00, 0xc21f64c7) |
| 6094 | mstore(0x20, p0) |
| 6095 | mstore(0x40, p1) |
| 6096 | mstore(0x60, 0x80) |
| 6097 | mstore(0x80, p3) |
| 6098 | writeString(0xa0, p2) |
| 6099 | } |
| 6100 | _sendLogPayload(0x1c, 0xc4); |
| 6101 | /// @solidity memory-safe-assembly |
| 6102 | assembly { |
| 6103 | mstore(0x00, m0) |
| 6104 | mstore(0x20, m1) |
| 6105 | mstore(0x40, m2) |
| 6106 | mstore(0x60, m3) |
| 6107 | mstore(0x80, m4) |
| 6108 | mstore(0xa0, m5) |
| 6109 | mstore(0xc0, m6) |
| 6110 | } |
| 6111 | } |
| 6112 | |
| 6113 | function log(bool p0, address p1, bytes32 p2, bytes32 p3) internal pure { |
| 6114 | bytes32 m0; |
| 6115 | bytes32 m1; |
| 6116 | bytes32 m2; |
| 6117 | bytes32 m3; |
| 6118 | bytes32 m4; |
| 6119 | bytes32 m5; |
| 6120 | bytes32 m6; |
| 6121 | bytes32 m7; |
| 6122 | bytes32 m8; |
| 6123 | /// @solidity memory-safe-assembly |
| 6124 | assembly { |
| 6125 | function writeString(pos, w) { |
| 6126 | let length := 0 |
| 6127 | for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } |
| 6128 | mstore(pos, length) |
| 6129 | let shift := sub(256, shl(3, length)) |
| 6130 | mstore(add(pos, 0x20), shl(shift, shr(shift, w))) |
| 6131 | } |
| 6132 | m0 := mload(0x00) |
| 6133 | m1 := mload(0x20) |
| 6134 | m2 := mload(0x40) |
| 6135 | m3 := mload(0x60) |
| 6136 | m4 := mload(0x80) |
| 6137 | m5 := mload(0xa0) |
| 6138 | m6 := mload(0xc0) |
| 6139 | m7 := mload(0xe0) |
| 6140 | m8 := mload(0x100) |
| 6141 | // Selector of `log(bool,address,string,string)`. |
| 6142 | mstore(0x00, 0xa73c1db6) |
| 6143 | mstore(0x20, p0) |
| 6144 | mstore(0x40, p1) |
| 6145 | mstore(0x60, 0x80) |
| 6146 | mstore(0x80, 0xc0) |
| 6147 | writeString(0xa0, p2) |
| 6148 | writeString(0xe0, p3) |
| 6149 | } |
| 6150 | _sendLogPayload(0x1c, 0x104); |
| 6151 | /// @solidity memory-safe-assembly |
| 6152 | assembly { |
| 6153 | mstore(0x00, m0) |
| 6154 | mstore(0x20, m1) |
| 6155 | mstore(0x40, m2) |
| 6156 | mstore(0x60, m3) |
| 6157 | mstore(0x80, m4) |
| 6158 | mstore(0xa0, m5) |
| 6159 | mstore(0xc0, m6) |
| 6160 | mstore(0xe0, m7) |
| 6161 | mstore(0x100, m8) |
| 6162 | } |
| 6163 | } |
| 6164 | |
| 6165 | function log(bool p0, bool p1, address p2, address p3) internal pure { |
| 6166 | bytes32 m0; |
| 6167 | bytes32 m1; |
| 6168 | bytes32 m2; |
| 6169 | bytes32 m3; |
| 6170 | bytes32 m4; |
| 6171 | /// @solidity memory-safe-assembly |
| 6172 | assembly { |
| 6173 | m0 := mload(0x00) |
| 6174 | m1 := mload(0x20) |
| 6175 | m2 := mload(0x40) |
| 6176 | m3 := mload(0x60) |
| 6177 | m4 := mload(0x80) |
| 6178 | // Selector of `log(bool,bool,address,address)`. |
| 6179 | mstore(0x00, 0xf4880ea4) |
| 6180 | mstore(0x20, p0) |
| 6181 | mstore(0x40, p1) |
| 6182 | mstore(0x60, p2) |
| 6183 | mstore(0x80, p3) |
| 6184 | } |
| 6185 | _sendLogPayload(0x1c, 0x84); |
| 6186 | /// @solidity memory-safe-assembly |
| 6187 | assembly { |
| 6188 | mstore(0x00, m0) |
| 6189 | mstore(0x20, m1) |
| 6190 | mstore(0x40, m2) |
| 6191 | mstore(0x60, m3) |
| 6192 | mstore(0x80, m4) |
| 6193 | } |
| 6194 | } |
| 6195 | |
| 6196 | function log(bool p0, bool p1, address p2, bool p3) internal pure { |
| 6197 | bytes32 m0; |
| 6198 | bytes32 m1; |
| 6199 | bytes32 m2; |
| 6200 | bytes32 m3; |
| 6201 | bytes32 m4; |
| 6202 | /// @solidity memory-safe-assembly |
| 6203 | assembly { |
| 6204 | m0 := mload(0x00) |
| 6205 | m1 := mload(0x20) |
| 6206 | m2 := mload(0x40) |
| 6207 | m3 := mload(0x60) |
| 6208 | m4 := mload(0x80) |
| 6209 | // Selector of `log(bool,bool,address,bool)`. |
| 6210 | mstore(0x00, 0xc0a302d8) |
| 6211 | mstore(0x20, p0) |
| 6212 | mstore(0x40, p1) |
| 6213 | mstore(0x60, p2) |
| 6214 | mstore(0x80, p3) |
| 6215 | } |
| 6216 | _sendLogPayload(0x1c, 0x84); |
| 6217 | /// @solidity memory-safe-assembly |
| 6218 | assembly { |
| 6219 | mstore(0x00, m0) |
| 6220 | mstore(0x20, m1) |
| 6221 | mstore(0x40, m2) |
| 6222 | mstore(0x60, m3) |
| 6223 | mstore(0x80, m4) |
| 6224 | } |
| 6225 | } |
| 6226 | |
| 6227 | function log(bool p0, bool p1, address p2, uint256 p3) internal pure { |
| 6228 | bytes32 m0; |
| 6229 | bytes32 m1; |
| 6230 | bytes32 m2; |
| 6231 | bytes32 m3; |
| 6232 | bytes32 m4; |
| 6233 | /// @solidity memory-safe-assembly |
| 6234 | assembly { |
| 6235 | m0 := mload(0x00) |
| 6236 | m1 := mload(0x20) |
| 6237 | m2 := mload(0x40) |
| 6238 | m3 := mload(0x60) |
| 6239 | m4 := mload(0x80) |
| 6240 | // Selector of `log(bool,bool,address,uint256)`. |
| 6241 | mstore(0x00, 0x4c123d57) |
| 6242 | mstore(0x20, p0) |
| 6243 | mstore(0x40, p1) |
| 6244 | mstore(0x60, p2) |
| 6245 | mstore(0x80, p3) |
| 6246 | } |
| 6247 | _sendLogPayload(0x1c, 0x84); |
| 6248 | /// @solidity memory-safe-assembly |
| 6249 | assembly { |
| 6250 | mstore(0x00, m0) |
| 6251 | mstore(0x20, m1) |
| 6252 | mstore(0x40, m2) |
| 6253 | mstore(0x60, m3) |
| 6254 | mstore(0x80, m4) |
| 6255 | } |
| 6256 | } |
| 6257 | |
| 6258 | function log(bool p0, bool p1, address p2, bytes32 p3) internal pure { |
| 6259 | bytes32 m0; |
| 6260 | bytes32 m1; |
| 6261 | bytes32 m2; |
| 6262 | bytes32 m3; |
| 6263 | bytes32 m4; |
| 6264 | bytes32 m5; |
| 6265 | bytes32 m6; |
| 6266 | /// @solidity memory-safe-assembly |
| 6267 | assembly { |
| 6268 | function writeString(pos, w) { |
| 6269 | let length := 0 |
| 6270 | for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } |
| 6271 | mstore(pos, length) |
| 6272 | let shift := sub(256, shl(3, length)) |
| 6273 | mstore(add(pos, 0x20), shl(shift, shr(shift, w))) |
| 6274 | } |
| 6275 | m0 := mload(0x00) |
| 6276 | m1 := mload(0x20) |
| 6277 | m2 := mload(0x40) |
| 6278 | m3 := mload(0x60) |
| 6279 | m4 := mload(0x80) |
| 6280 | m5 := mload(0xa0) |
| 6281 | m6 := mload(0xc0) |
| 6282 | // Selector of `log(bool,bool,address,string)`. |
| 6283 | mstore(0x00, 0xa0a47963) |
| 6284 | mstore(0x20, p0) |
| 6285 | mstore(0x40, p1) |
| 6286 | mstore(0x60, p2) |
| 6287 | mstore(0x80, 0x80) |
| 6288 | writeString(0xa0, p3) |
| 6289 | } |
| 6290 | _sendLogPayload(0x1c, 0xc4); |
| 6291 | /// @solidity memory-safe-assembly |
| 6292 | assembly { |
| 6293 | mstore(0x00, m0) |
| 6294 | mstore(0x20, m1) |
| 6295 | mstore(0x40, m2) |
| 6296 | mstore(0x60, m3) |
| 6297 | mstore(0x80, m4) |
| 6298 | mstore(0xa0, m5) |
| 6299 | mstore(0xc0, m6) |
| 6300 | } |
| 6301 | } |
| 6302 | |
| 6303 | function log(bool p0, bool p1, bool p2, address p3) internal pure { |
| 6304 | bytes32 m0; |
| 6305 | bytes32 m1; |
| 6306 | bytes32 m2; |
| 6307 | bytes32 m3; |
| 6308 | bytes32 m4; |
| 6309 | /// @solidity memory-safe-assembly |
| 6310 | assembly { |
| 6311 | m0 := mload(0x00) |
| 6312 | m1 := mload(0x20) |
| 6313 | m2 := mload(0x40) |
| 6314 | m3 := mload(0x60) |
| 6315 | m4 := mload(0x80) |
| 6316 | // Selector of `log(bool,bool,bool,address)`. |
| 6317 | mstore(0x00, 0x8c329b1a) |
| 6318 | mstore(0x20, p0) |
| 6319 | mstore(0x40, p1) |
| 6320 | mstore(0x60, p2) |
| 6321 | mstore(0x80, p3) |
| 6322 | } |
| 6323 | _sendLogPayload(0x1c, 0x84); |
| 6324 | /// @solidity memory-safe-assembly |
| 6325 | assembly { |
| 6326 | mstore(0x00, m0) |
| 6327 | mstore(0x20, m1) |
| 6328 | mstore(0x40, m2) |
| 6329 | mstore(0x60, m3) |
| 6330 | mstore(0x80, m4) |
| 6331 | } |
| 6332 | } |
| 6333 | |
| 6334 | function log(bool p0, bool p1, bool p2, bool p3) internal pure { |
| 6335 | bytes32 m0; |
| 6336 | bytes32 m1; |
| 6337 | bytes32 m2; |
| 6338 | bytes32 m3; |
| 6339 | bytes32 m4; |
| 6340 | /// @solidity memory-safe-assembly |
| 6341 | assembly { |
| 6342 | m0 := mload(0x00) |
| 6343 | m1 := mload(0x20) |
| 6344 | m2 := mload(0x40) |
| 6345 | m3 := mload(0x60) |
| 6346 | m4 := mload(0x80) |
| 6347 | // Selector of `log(bool,bool,bool,bool)`. |
| 6348 | mstore(0x00, 0x3b2a5ce0) |
| 6349 | mstore(0x20, p0) |
| 6350 | mstore(0x40, p1) |
| 6351 | mstore(0x60, p2) |
| 6352 | mstore(0x80, p3) |
| 6353 | } |
| 6354 | _sendLogPayload(0x1c, 0x84); |
| 6355 | /// @solidity memory-safe-assembly |
| 6356 | assembly { |
| 6357 | mstore(0x00, m0) |
| 6358 | mstore(0x20, m1) |
| 6359 | mstore(0x40, m2) |
| 6360 | mstore(0x60, m3) |
| 6361 | mstore(0x80, m4) |
| 6362 | } |
| 6363 | } |
| 6364 | |
| 6365 | function log(bool p0, bool p1, bool p2, uint256 p3) internal pure { |
| 6366 | bytes32 m0; |
| 6367 | bytes32 m1; |
| 6368 | bytes32 m2; |
| 6369 | bytes32 m3; |
| 6370 | bytes32 m4; |
| 6371 | /// @solidity memory-safe-assembly |
| 6372 | assembly { |
| 6373 | m0 := mload(0x00) |
| 6374 | m1 := mload(0x20) |
| 6375 | m2 := mload(0x40) |
| 6376 | m3 := mload(0x60) |
| 6377 | m4 := mload(0x80) |
| 6378 | // Selector of `log(bool,bool,bool,uint256)`. |
| 6379 | mstore(0x00, 0x6d7045c1) |
| 6380 | mstore(0x20, p0) |
| 6381 | mstore(0x40, p1) |
| 6382 | mstore(0x60, p2) |
| 6383 | mstore(0x80, p3) |
| 6384 | } |
| 6385 | _sendLogPayload(0x1c, 0x84); |
| 6386 | /// @solidity memory-safe-assembly |
| 6387 | assembly { |
| 6388 | mstore(0x00, m0) |
| 6389 | mstore(0x20, m1) |
| 6390 | mstore(0x40, m2) |
| 6391 | mstore(0x60, m3) |
| 6392 | mstore(0x80, m4) |
| 6393 | } |
| 6394 | } |
| 6395 | |
| 6396 | function log(bool p0, bool p1, bool p2, bytes32 p3) internal pure { |
| 6397 | bytes32 m0; |
| 6398 | bytes32 m1; |
| 6399 | bytes32 m2; |
| 6400 | bytes32 m3; |
| 6401 | bytes32 m4; |
| 6402 | bytes32 m5; |
| 6403 | bytes32 m6; |
| 6404 | /// @solidity memory-safe-assembly |
| 6405 | assembly { |
| 6406 | function writeString(pos, w) { |
| 6407 | let length := 0 |
| 6408 | for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } |
| 6409 | mstore(pos, length) |
| 6410 | let shift := sub(256, shl(3, length)) |
| 6411 | mstore(add(pos, 0x20), shl(shift, shr(shift, w))) |
| 6412 | } |
| 6413 | m0 := mload(0x00) |
| 6414 | m1 := mload(0x20) |
| 6415 | m2 := mload(0x40) |
| 6416 | m3 := mload(0x60) |
| 6417 | m4 := mload(0x80) |
| 6418 | m5 := mload(0xa0) |
| 6419 | m6 := mload(0xc0) |
| 6420 | // Selector of `log(bool,bool,bool,string)`. |
| 6421 | mstore(0x00, 0x2ae408d4) |
| 6422 | mstore(0x20, p0) |
| 6423 | mstore(0x40, p1) |
| 6424 | mstore(0x60, p2) |
| 6425 | mstore(0x80, 0x80) |
| 6426 | writeString(0xa0, p3) |
| 6427 | } |
| 6428 | _sendLogPayload(0x1c, 0xc4); |
| 6429 | /// @solidity memory-safe-assembly |
| 6430 | assembly { |
| 6431 | mstore(0x00, m0) |
| 6432 | mstore(0x20, m1) |
| 6433 | mstore(0x40, m2) |
| 6434 | mstore(0x60, m3) |
| 6435 | mstore(0x80, m4) |
| 6436 | mstore(0xa0, m5) |
| 6437 | mstore(0xc0, m6) |
| 6438 | } |
| 6439 | } |
| 6440 | |
| 6441 | function log(bool p0, bool p1, uint256 p2, address p3) internal pure { |
| 6442 | bytes32 m0; |
| 6443 | bytes32 m1; |
| 6444 | bytes32 m2; |
| 6445 | bytes32 m3; |
| 6446 | bytes32 m4; |
| 6447 | /// @solidity memory-safe-assembly |
| 6448 | assembly { |
| 6449 | m0 := mload(0x00) |
| 6450 | m1 := mload(0x20) |
| 6451 | m2 := mload(0x40) |
| 6452 | m3 := mload(0x60) |
| 6453 | m4 := mload(0x80) |
| 6454 | // Selector of `log(bool,bool,uint256,address)`. |
| 6455 | mstore(0x00, 0x54a7a9a0) |
| 6456 | mstore(0x20, p0) |
| 6457 | mstore(0x40, p1) |
| 6458 | mstore(0x60, p2) |
| 6459 | mstore(0x80, p3) |
| 6460 | } |
| 6461 | _sendLogPayload(0x1c, 0x84); |
| 6462 | /// @solidity memory-safe-assembly |
| 6463 | assembly { |
| 6464 | mstore(0x00, m0) |
| 6465 | mstore(0x20, m1) |
| 6466 | mstore(0x40, m2) |
| 6467 | mstore(0x60, m3) |
| 6468 | mstore(0x80, m4) |
| 6469 | } |
| 6470 | } |
| 6471 | |
| 6472 | function log(bool p0, bool p1, uint256 p2, bool p3) internal pure { |
| 6473 | bytes32 m0; |
| 6474 | bytes32 m1; |
| 6475 | bytes32 m2; |
| 6476 | bytes32 m3; |
| 6477 | bytes32 m4; |
| 6478 | /// @solidity memory-safe-assembly |
| 6479 | assembly { |
| 6480 | m0 := mload(0x00) |
| 6481 | m1 := mload(0x20) |
| 6482 | m2 := mload(0x40) |
| 6483 | m3 := mload(0x60) |
| 6484 | m4 := mload(0x80) |
| 6485 | // Selector of `log(bool,bool,uint256,bool)`. |
| 6486 | mstore(0x00, 0x619e4d0e) |
| 6487 | mstore(0x20, p0) |
| 6488 | mstore(0x40, p1) |
| 6489 | mstore(0x60, p2) |
| 6490 | mstore(0x80, p3) |
| 6491 | } |
| 6492 | _sendLogPayload(0x1c, 0x84); |
| 6493 | /// @solidity memory-safe-assembly |
| 6494 | assembly { |
| 6495 | mstore(0x00, m0) |
| 6496 | mstore(0x20, m1) |
| 6497 | mstore(0x40, m2) |
| 6498 | mstore(0x60, m3) |
| 6499 | mstore(0x80, m4) |
| 6500 | } |
| 6501 | } |
| 6502 | |
| 6503 | function log(bool p0, bool p1, uint256 p2, uint256 p3) internal pure { |
| 6504 | bytes32 m0; |
| 6505 | bytes32 m1; |
| 6506 | bytes32 m2; |
| 6507 | bytes32 m3; |
| 6508 | bytes32 m4; |
| 6509 | /// @solidity memory-safe-assembly |
| 6510 | assembly { |
| 6511 | m0 := mload(0x00) |
| 6512 | m1 := mload(0x20) |
| 6513 | m2 := mload(0x40) |
| 6514 | m3 := mload(0x60) |
| 6515 | m4 := mload(0x80) |
| 6516 | // Selector of `log(bool,bool,uint256,uint256)`. |
| 6517 | mstore(0x00, 0x0bb00eab) |
| 6518 | mstore(0x20, p0) |
| 6519 | mstore(0x40, p1) |
| 6520 | mstore(0x60, p2) |
| 6521 | mstore(0x80, p3) |
| 6522 | } |
| 6523 | _sendLogPayload(0x1c, 0x84); |
| 6524 | /// @solidity memory-safe-assembly |
| 6525 | assembly { |
| 6526 | mstore(0x00, m0) |
| 6527 | mstore(0x20, m1) |
| 6528 | mstore(0x40, m2) |
| 6529 | mstore(0x60, m3) |
| 6530 | mstore(0x80, m4) |
| 6531 | } |
| 6532 | } |
| 6533 | |
| 6534 | function log(bool p0, bool p1, uint256 p2, bytes32 p3) internal pure { |
| 6535 | bytes32 m0; |
| 6536 | bytes32 m1; |
| 6537 | bytes32 m2; |
| 6538 | bytes32 m3; |
| 6539 | bytes32 m4; |
| 6540 | bytes32 m5; |
| 6541 | bytes32 m6; |
| 6542 | /// @solidity memory-safe-assembly |
| 6543 | assembly { |
| 6544 | function writeString(pos, w) { |
| 6545 | let length := 0 |
| 6546 | for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } |
| 6547 | mstore(pos, length) |
| 6548 | let shift := sub(256, shl(3, length)) |
| 6549 | mstore(add(pos, 0x20), shl(shift, shr(shift, w))) |
| 6550 | } |
| 6551 | m0 := mload(0x00) |
| 6552 | m1 := mload(0x20) |
| 6553 | m2 := mload(0x40) |
| 6554 | m3 := mload(0x60) |
| 6555 | m4 := mload(0x80) |
| 6556 | m5 := mload(0xa0) |
| 6557 | m6 := mload(0xc0) |
| 6558 | // Selector of `log(bool,bool,uint256,string)`. |
| 6559 | mstore(0x00, 0x7dd4d0e0) |
| 6560 | mstore(0x20, p0) |
| 6561 | mstore(0x40, p1) |
| 6562 | mstore(0x60, p2) |
| 6563 | mstore(0x80, 0x80) |
| 6564 | writeString(0xa0, p3) |
| 6565 | } |
| 6566 | _sendLogPayload(0x1c, 0xc4); |
| 6567 | /// @solidity memory-safe-assembly |
| 6568 | assembly { |
| 6569 | mstore(0x00, m0) |
| 6570 | mstore(0x20, m1) |
| 6571 | mstore(0x40, m2) |
| 6572 | mstore(0x60, m3) |
| 6573 | mstore(0x80, m4) |
| 6574 | mstore(0xa0, m5) |
| 6575 | mstore(0xc0, m6) |
| 6576 | } |
| 6577 | } |
| 6578 | |
| 6579 | function log(bool p0, bool p1, bytes32 p2, address p3) internal pure { |
| 6580 | bytes32 m0; |
| 6581 | bytes32 m1; |
| 6582 | bytes32 m2; |
| 6583 | bytes32 m3; |
| 6584 | bytes32 m4; |
| 6585 | bytes32 m5; |
| 6586 | bytes32 m6; |
| 6587 | /// @solidity memory-safe-assembly |
| 6588 | assembly { |
| 6589 | function writeString(pos, w) { |
| 6590 | let length := 0 |
| 6591 | for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } |
| 6592 | mstore(pos, length) |
| 6593 | let shift := sub(256, shl(3, length)) |
| 6594 | mstore(add(pos, 0x20), shl(shift, shr(shift, w))) |
| 6595 | } |
| 6596 | m0 := mload(0x00) |
| 6597 | m1 := mload(0x20) |
| 6598 | m2 := mload(0x40) |
| 6599 | m3 := mload(0x60) |
| 6600 | m4 := mload(0x80) |
| 6601 | m5 := mload(0xa0) |
| 6602 | m6 := mload(0xc0) |
| 6603 | // Selector of `log(bool,bool,string,address)`. |
| 6604 | mstore(0x00, 0xf9ad2b89) |
| 6605 | mstore(0x20, p0) |
| 6606 | mstore(0x40, p1) |
| 6607 | mstore(0x60, 0x80) |
| 6608 | mstore(0x80, p3) |
| 6609 | writeString(0xa0, p2) |
| 6610 | } |
| 6611 | _sendLogPayload(0x1c, 0xc4); |
| 6612 | /// @solidity memory-safe-assembly |
| 6613 | assembly { |
| 6614 | mstore(0x00, m0) |
| 6615 | mstore(0x20, m1) |
| 6616 | mstore(0x40, m2) |
| 6617 | mstore(0x60, m3) |
| 6618 | mstore(0x80, m4) |
| 6619 | mstore(0xa0, m5) |
| 6620 | mstore(0xc0, m6) |
| 6621 | } |
| 6622 | } |
| 6623 | |
| 6624 | function log(bool p0, bool p1, bytes32 p2, bool p3) internal pure { |
| 6625 | bytes32 m0; |
| 6626 | bytes32 m1; |
| 6627 | bytes32 m2; |
| 6628 | bytes32 m3; |
| 6629 | bytes32 m4; |
| 6630 | bytes32 m5; |
| 6631 | bytes32 m6; |
| 6632 | /// @solidity memory-safe-assembly |
| 6633 | assembly { |
| 6634 | function writeString(pos, w) { |
| 6635 | let length := 0 |
| 6636 | for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } |
| 6637 | mstore(pos, length) |
| 6638 | let shift := sub(256, shl(3, length)) |
| 6639 | mstore(add(pos, 0x20), shl(shift, shr(shift, w))) |
| 6640 | } |
| 6641 | m0 := mload(0x00) |
| 6642 | m1 := mload(0x20) |
| 6643 | m2 := mload(0x40) |
| 6644 | m3 := mload(0x60) |
| 6645 | m4 := mload(0x80) |
| 6646 | m5 := mload(0xa0) |
| 6647 | m6 := mload(0xc0) |
| 6648 | // Selector of `log(bool,bool,string,bool)`. |
| 6649 | mstore(0x00, 0xb857163a) |
| 6650 | mstore(0x20, p0) |
| 6651 | mstore(0x40, p1) |
| 6652 | mstore(0x60, 0x80) |
| 6653 | mstore(0x80, p3) |
| 6654 | writeString(0xa0, p2) |
| 6655 | } |
| 6656 | _sendLogPayload(0x1c, 0xc4); |
| 6657 | /// @solidity memory-safe-assembly |
| 6658 | assembly { |
| 6659 | mstore(0x00, m0) |
| 6660 | mstore(0x20, m1) |
| 6661 | mstore(0x40, m2) |
| 6662 | mstore(0x60, m3) |
| 6663 | mstore(0x80, m4) |
| 6664 | mstore(0xa0, m5) |
| 6665 | mstore(0xc0, m6) |
| 6666 | } |
| 6667 | } |
| 6668 | |
| 6669 | function log(bool p0, bool p1, bytes32 p2, uint256 p3) internal pure { |
| 6670 | bytes32 m0; |
| 6671 | bytes32 m1; |
| 6672 | bytes32 m2; |
| 6673 | bytes32 m3; |
| 6674 | bytes32 m4; |
| 6675 | bytes32 m5; |
| 6676 | bytes32 m6; |
| 6677 | /// @solidity memory-safe-assembly |
| 6678 | assembly { |
| 6679 | function writeString(pos, w) { |
| 6680 | let length := 0 |
| 6681 | for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } |
| 6682 | mstore(pos, length) |
| 6683 | let shift := sub(256, shl(3, length)) |
| 6684 | mstore(add(pos, 0x20), shl(shift, shr(shift, w))) |
| 6685 | } |
| 6686 | m0 := mload(0x00) |
| 6687 | m1 := mload(0x20) |
| 6688 | m2 := mload(0x40) |
| 6689 | m3 := mload(0x60) |
| 6690 | m4 := mload(0x80) |
| 6691 | m5 := mload(0xa0) |
| 6692 | m6 := mload(0xc0) |
| 6693 | // Selector of `log(bool,bool,string,uint256)`. |
| 6694 | mstore(0x00, 0xe3a9ca2f) |
| 6695 | mstore(0x20, p0) |
| 6696 | mstore(0x40, p1) |
| 6697 | mstore(0x60, 0x80) |
| 6698 | mstore(0x80, p3) |
| 6699 | writeString(0xa0, p2) |
| 6700 | } |
| 6701 | _sendLogPayload(0x1c, 0xc4); |
| 6702 | /// @solidity memory-safe-assembly |
| 6703 | assembly { |
| 6704 | mstore(0x00, m0) |
| 6705 | mstore(0x20, m1) |
| 6706 | mstore(0x40, m2) |
| 6707 | mstore(0x60, m3) |
| 6708 | mstore(0x80, m4) |
| 6709 | mstore(0xa0, m5) |
| 6710 | mstore(0xc0, m6) |
| 6711 | } |
| 6712 | } |
| 6713 | |
| 6714 | function log(bool p0, bool p1, bytes32 p2, bytes32 p3) internal pure { |
| 6715 | bytes32 m0; |
| 6716 | bytes32 m1; |
| 6717 | bytes32 m2; |
| 6718 | bytes32 m3; |
| 6719 | bytes32 m4; |
| 6720 | bytes32 m5; |
| 6721 | bytes32 m6; |
| 6722 | bytes32 m7; |
| 6723 | bytes32 m8; |
| 6724 | /// @solidity memory-safe-assembly |
| 6725 | assembly { |
| 6726 | function writeString(pos, w) { |
| 6727 | let length := 0 |
| 6728 | for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } |
| 6729 | mstore(pos, length) |
| 6730 | let shift := sub(256, shl(3, length)) |
| 6731 | mstore(add(pos, 0x20), shl(shift, shr(shift, w))) |
| 6732 | } |
| 6733 | m0 := mload(0x00) |
| 6734 | m1 := mload(0x20) |
| 6735 | m2 := mload(0x40) |
| 6736 | m3 := mload(0x60) |
| 6737 | m4 := mload(0x80) |
| 6738 | m5 := mload(0xa0) |
| 6739 | m6 := mload(0xc0) |
| 6740 | m7 := mload(0xe0) |
| 6741 | m8 := mload(0x100) |
| 6742 | // Selector of `log(bool,bool,string,string)`. |
| 6743 | mstore(0x00, 0x6d1e8751) |
| 6744 | mstore(0x20, p0) |
| 6745 | mstore(0x40, p1) |
| 6746 | mstore(0x60, 0x80) |
| 6747 | mstore(0x80, 0xc0) |
| 6748 | writeString(0xa0, p2) |
| 6749 | writeString(0xe0, p3) |
| 6750 | } |
| 6751 | _sendLogPayload(0x1c, 0x104); |
| 6752 | /// @solidity memory-safe-assembly |
| 6753 | assembly { |
| 6754 | mstore(0x00, m0) |
| 6755 | mstore(0x20, m1) |
| 6756 | mstore(0x40, m2) |
| 6757 | mstore(0x60, m3) |
| 6758 | mstore(0x80, m4) |
| 6759 | mstore(0xa0, m5) |
| 6760 | mstore(0xc0, m6) |
| 6761 | mstore(0xe0, m7) |
| 6762 | mstore(0x100, m8) |
| 6763 | } |
| 6764 | } |
| 6765 | |
| 6766 | function log(bool p0, uint256 p1, address p2, address p3) internal pure { |
| 6767 | bytes32 m0; |
| 6768 | bytes32 m1; |
| 6769 | bytes32 m2; |
| 6770 | bytes32 m3; |
| 6771 | bytes32 m4; |
| 6772 | /// @solidity memory-safe-assembly |
| 6773 | assembly { |
| 6774 | m0 := mload(0x00) |
| 6775 | m1 := mload(0x20) |
| 6776 | m2 := mload(0x40) |
| 6777 | m3 := mload(0x60) |
| 6778 | m4 := mload(0x80) |
| 6779 | // Selector of `log(bool,uint256,address,address)`. |
| 6780 | mstore(0x00, 0x26f560a8) |
| 6781 | mstore(0x20, p0) |
| 6782 | mstore(0x40, p1) |
| 6783 | mstore(0x60, p2) |
| 6784 | mstore(0x80, p3) |
| 6785 | } |
| 6786 | _sendLogPayload(0x1c, 0x84); |
| 6787 | /// @solidity memory-safe-assembly |
| 6788 | assembly { |
| 6789 | mstore(0x00, m0) |
| 6790 | mstore(0x20, m1) |
| 6791 | mstore(0x40, m2) |
| 6792 | mstore(0x60, m3) |
| 6793 | mstore(0x80, m4) |
| 6794 | } |
| 6795 | } |
| 6796 | |
| 6797 | function log(bool p0, uint256 p1, address p2, bool p3) internal pure { |
| 6798 | bytes32 m0; |
| 6799 | bytes32 m1; |
| 6800 | bytes32 m2; |
| 6801 | bytes32 m3; |
| 6802 | bytes32 m4; |
| 6803 | /// @solidity memory-safe-assembly |
| 6804 | assembly { |
| 6805 | m0 := mload(0x00) |
| 6806 | m1 := mload(0x20) |
| 6807 | m2 := mload(0x40) |
| 6808 | m3 := mload(0x60) |
| 6809 | m4 := mload(0x80) |
| 6810 | // Selector of `log(bool,uint256,address,bool)`. |
| 6811 | mstore(0x00, 0xb4c314ff) |
| 6812 | mstore(0x20, p0) |
| 6813 | mstore(0x40, p1) |
| 6814 | mstore(0x60, p2) |
| 6815 | mstore(0x80, p3) |
| 6816 | } |
| 6817 | _sendLogPayload(0x1c, 0x84); |
| 6818 | /// @solidity memory-safe-assembly |
| 6819 | assembly { |
| 6820 | mstore(0x00, m0) |
| 6821 | mstore(0x20, m1) |
| 6822 | mstore(0x40, m2) |
| 6823 | mstore(0x60, m3) |
| 6824 | mstore(0x80, m4) |
| 6825 | } |
| 6826 | } |
| 6827 | |
| 6828 | function log(bool p0, uint256 p1, address p2, uint256 p3) internal pure { |
| 6829 | bytes32 m0; |
| 6830 | bytes32 m1; |
| 6831 | bytes32 m2; |
| 6832 | bytes32 m3; |
| 6833 | bytes32 m4; |
| 6834 | /// @solidity memory-safe-assembly |
| 6835 | assembly { |
| 6836 | m0 := mload(0x00) |
| 6837 | m1 := mload(0x20) |
| 6838 | m2 := mload(0x40) |
| 6839 | m3 := mload(0x60) |
| 6840 | m4 := mload(0x80) |
| 6841 | // Selector of `log(bool,uint256,address,uint256)`. |
| 6842 | mstore(0x00, 0x1537dc87) |
| 6843 | mstore(0x20, p0) |
| 6844 | mstore(0x40, p1) |
| 6845 | mstore(0x60, p2) |
| 6846 | mstore(0x80, p3) |
| 6847 | } |
| 6848 | _sendLogPayload(0x1c, 0x84); |
| 6849 | /// @solidity memory-safe-assembly |
| 6850 | assembly { |
| 6851 | mstore(0x00, m0) |
| 6852 | mstore(0x20, m1) |
| 6853 | mstore(0x40, m2) |
| 6854 | mstore(0x60, m3) |
| 6855 | mstore(0x80, m4) |
| 6856 | } |
| 6857 | } |
| 6858 | |
| 6859 | function log(bool p0, uint256 p1, address p2, bytes32 p3) internal pure { |
| 6860 | bytes32 m0; |
| 6861 | bytes32 m1; |
| 6862 | bytes32 m2; |
| 6863 | bytes32 m3; |
| 6864 | bytes32 m4; |
| 6865 | bytes32 m5; |
| 6866 | bytes32 m6; |
| 6867 | /// @solidity memory-safe-assembly |
| 6868 | assembly { |
| 6869 | function writeString(pos, w) { |
| 6870 | let length := 0 |
| 6871 | for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } |
| 6872 | mstore(pos, length) |
| 6873 | let shift := sub(256, shl(3, length)) |
| 6874 | mstore(add(pos, 0x20), shl(shift, shr(shift, w))) |
| 6875 | } |
| 6876 | m0 := mload(0x00) |
| 6877 | m1 := mload(0x20) |
| 6878 | m2 := mload(0x40) |
| 6879 | m3 := mload(0x60) |
| 6880 | m4 := mload(0x80) |
| 6881 | m5 := mload(0xa0) |
| 6882 | m6 := mload(0xc0) |
| 6883 | // Selector of `log(bool,uint256,address,string)`. |
| 6884 | mstore(0x00, 0x1bb3b09a) |
| 6885 | mstore(0x20, p0) |
| 6886 | mstore(0x40, p1) |
| 6887 | mstore(0x60, p2) |
| 6888 | mstore(0x80, 0x80) |
| 6889 | writeString(0xa0, p3) |
| 6890 | } |
| 6891 | _sendLogPayload(0x1c, 0xc4); |
| 6892 | /// @solidity memory-safe-assembly |
| 6893 | assembly { |
| 6894 | mstore(0x00, m0) |
| 6895 | mstore(0x20, m1) |
| 6896 | mstore(0x40, m2) |
| 6897 | mstore(0x60, m3) |
| 6898 | mstore(0x80, m4) |
| 6899 | mstore(0xa0, m5) |
| 6900 | mstore(0xc0, m6) |
| 6901 | } |
| 6902 | } |
| 6903 | |
| 6904 | function log(bool p0, uint256 p1, bool p2, address p3) internal pure { |
| 6905 | bytes32 m0; |
| 6906 | bytes32 m1; |
| 6907 | bytes32 m2; |
| 6908 | bytes32 m3; |
| 6909 | bytes32 m4; |
| 6910 | /// @solidity memory-safe-assembly |
| 6911 | assembly { |
| 6912 | m0 := mload(0x00) |
| 6913 | m1 := mload(0x20) |
| 6914 | m2 := mload(0x40) |
| 6915 | m3 := mload(0x60) |
| 6916 | m4 := mload(0x80) |
| 6917 | // Selector of `log(bool,uint256,bool,address)`. |
| 6918 | mstore(0x00, 0x9acd3616) |
| 6919 | mstore(0x20, p0) |
| 6920 | mstore(0x40, p1) |
| 6921 | mstore(0x60, p2) |
| 6922 | mstore(0x80, p3) |
| 6923 | } |
| 6924 | _sendLogPayload(0x1c, 0x84); |
| 6925 | /// @solidity memory-safe-assembly |
| 6926 | assembly { |
| 6927 | mstore(0x00, m0) |
| 6928 | mstore(0x20, m1) |
| 6929 | mstore(0x40, m2) |
| 6930 | mstore(0x60, m3) |
| 6931 | mstore(0x80, m4) |
| 6932 | } |
| 6933 | } |
| 6934 | |
| 6935 | function log(bool p0, uint256 p1, bool p2, bool p3) internal pure { |
| 6936 | bytes32 m0; |
| 6937 | bytes32 m1; |
| 6938 | bytes32 m2; |
| 6939 | bytes32 m3; |
| 6940 | bytes32 m4; |
| 6941 | /// @solidity memory-safe-assembly |
| 6942 | assembly { |
| 6943 | m0 := mload(0x00) |
| 6944 | m1 := mload(0x20) |
| 6945 | m2 := mload(0x40) |
| 6946 | m3 := mload(0x60) |
| 6947 | m4 := mload(0x80) |
| 6948 | // Selector of `log(bool,uint256,bool,bool)`. |
| 6949 | mstore(0x00, 0xceb5f4d7) |
| 6950 | mstore(0x20, p0) |
| 6951 | mstore(0x40, p1) |
| 6952 | mstore(0x60, p2) |
| 6953 | mstore(0x80, p3) |
| 6954 | } |
| 6955 | _sendLogPayload(0x1c, 0x84); |
| 6956 | /// @solidity memory-safe-assembly |
| 6957 | assembly { |
| 6958 | mstore(0x00, m0) |
| 6959 | mstore(0x20, m1) |
| 6960 | mstore(0x40, m2) |
| 6961 | mstore(0x60, m3) |
| 6962 | mstore(0x80, m4) |
| 6963 | } |
| 6964 | } |
| 6965 | |
| 6966 | function log(bool p0, uint256 p1, bool p2, uint256 p3) internal pure { |
| 6967 | bytes32 m0; |
| 6968 | bytes32 m1; |
| 6969 | bytes32 m2; |
| 6970 | bytes32 m3; |
| 6971 | bytes32 m4; |
| 6972 | /// @solidity memory-safe-assembly |
| 6973 | assembly { |
| 6974 | m0 := mload(0x00) |
| 6975 | m1 := mload(0x20) |
| 6976 | m2 := mload(0x40) |
| 6977 | m3 := mload(0x60) |
| 6978 | m4 := mload(0x80) |
| 6979 | // Selector of `log(bool,uint256,bool,uint256)`. |
| 6980 | mstore(0x00, 0x7f9bbca2) |
| 6981 | mstore(0x20, p0) |
| 6982 | mstore(0x40, p1) |
| 6983 | mstore(0x60, p2) |
| 6984 | mstore(0x80, p3) |
| 6985 | } |
| 6986 | _sendLogPayload(0x1c, 0x84); |
| 6987 | /// @solidity memory-safe-assembly |
| 6988 | assembly { |
| 6989 | mstore(0x00, m0) |
| 6990 | mstore(0x20, m1) |
| 6991 | mstore(0x40, m2) |
| 6992 | mstore(0x60, m3) |
| 6993 | mstore(0x80, m4) |
| 6994 | } |
| 6995 | } |
| 6996 | |
| 6997 | function log(bool p0, uint256 p1, bool p2, bytes32 p3) internal pure { |
| 6998 | bytes32 m0; |
| 6999 | bytes32 m1; |
| 7000 | bytes32 m2; |
| 7001 | bytes32 m3; |
| 7002 | bytes32 m4; |
| 7003 | bytes32 m5; |
| 7004 | bytes32 m6; |
| 7005 | /// @solidity memory-safe-assembly |
| 7006 | assembly { |
| 7007 | function writeString(pos, w) { |
| 7008 | let length := 0 |
| 7009 | for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } |
| 7010 | mstore(pos, length) |
| 7011 | let shift := sub(256, shl(3, length)) |
| 7012 | mstore(add(pos, 0x20), shl(shift, shr(shift, w))) |
| 7013 | } |
| 7014 | m0 := mload(0x00) |
| 7015 | m1 := mload(0x20) |
| 7016 | m2 := mload(0x40) |
| 7017 | m3 := mload(0x60) |
| 7018 | m4 := mload(0x80) |
| 7019 | m5 := mload(0xa0) |
| 7020 | m6 := mload(0xc0) |
| 7021 | // Selector of `log(bool,uint256,bool,string)`. |
| 7022 | mstore(0x00, 0x9143dbb1) |
| 7023 | mstore(0x20, p0) |
| 7024 | mstore(0x40, p1) |
| 7025 | mstore(0x60, p2) |
| 7026 | mstore(0x80, 0x80) |
| 7027 | writeString(0xa0, p3) |
| 7028 | } |
| 7029 | _sendLogPayload(0x1c, 0xc4); |
| 7030 | /// @solidity memory-safe-assembly |
| 7031 | assembly { |
| 7032 | mstore(0x00, m0) |
| 7033 | mstore(0x20, m1) |
| 7034 | mstore(0x40, m2) |
| 7035 | mstore(0x60, m3) |
| 7036 | mstore(0x80, m4) |
| 7037 | mstore(0xa0, m5) |
| 7038 | mstore(0xc0, m6) |
| 7039 | } |
| 7040 | } |
| 7041 | |
| 7042 | function log(bool p0, uint256 p1, uint256 p2, address p3) internal pure { |
| 7043 | bytes32 m0; |
| 7044 | bytes32 m1; |
| 7045 | bytes32 m2; |
| 7046 | bytes32 m3; |
| 7047 | bytes32 m4; |
| 7048 | /// @solidity memory-safe-assembly |
| 7049 | assembly { |
| 7050 | m0 := mload(0x00) |
| 7051 | m1 := mload(0x20) |
| 7052 | m2 := mload(0x40) |
| 7053 | m3 := mload(0x60) |
| 7054 | m4 := mload(0x80) |
| 7055 | // Selector of `log(bool,uint256,uint256,address)`. |
| 7056 | mstore(0x00, 0x00dd87b9) |
| 7057 | mstore(0x20, p0) |
| 7058 | mstore(0x40, p1) |
| 7059 | mstore(0x60, p2) |
| 7060 | mstore(0x80, p3) |
| 7061 | } |
| 7062 | _sendLogPayload(0x1c, 0x84); |
| 7063 | /// @solidity memory-safe-assembly |
| 7064 | assembly { |
| 7065 | mstore(0x00, m0) |
| 7066 | mstore(0x20, m1) |
| 7067 | mstore(0x40, m2) |
| 7068 | mstore(0x60, m3) |
| 7069 | mstore(0x80, m4) |
| 7070 | } |
| 7071 | } |
| 7072 | |
| 7073 | function log(bool p0, uint256 p1, uint256 p2, bool p3) internal pure { |
| 7074 | bytes32 m0; |
| 7075 | bytes32 m1; |
| 7076 | bytes32 m2; |
| 7077 | bytes32 m3; |
| 7078 | bytes32 m4; |
| 7079 | /// @solidity memory-safe-assembly |
| 7080 | assembly { |
| 7081 | m0 := mload(0x00) |
| 7082 | m1 := mload(0x20) |
| 7083 | m2 := mload(0x40) |
| 7084 | m3 := mload(0x60) |
| 7085 | m4 := mload(0x80) |
| 7086 | // Selector of `log(bool,uint256,uint256,bool)`. |
| 7087 | mstore(0x00, 0xbe984353) |
| 7088 | mstore(0x20, p0) |
| 7089 | mstore(0x40, p1) |
| 7090 | mstore(0x60, p2) |
| 7091 | mstore(0x80, p3) |
| 7092 | } |
| 7093 | _sendLogPayload(0x1c, 0x84); |
| 7094 | /// @solidity memory-safe-assembly |
| 7095 | assembly { |
| 7096 | mstore(0x00, m0) |
| 7097 | mstore(0x20, m1) |
| 7098 | mstore(0x40, m2) |
| 7099 | mstore(0x60, m3) |
| 7100 | mstore(0x80, m4) |
| 7101 | } |
| 7102 | } |
| 7103 | |
| 7104 | function log(bool p0, uint256 p1, uint256 p2, uint256 p3) internal pure { |
| 7105 | bytes32 m0; |
| 7106 | bytes32 m1; |
| 7107 | bytes32 m2; |
| 7108 | bytes32 m3; |
| 7109 | bytes32 m4; |
| 7110 | /// @solidity memory-safe-assembly |
| 7111 | assembly { |
| 7112 | m0 := mload(0x00) |
| 7113 | m1 := mload(0x20) |
| 7114 | m2 := mload(0x40) |
| 7115 | m3 := mload(0x60) |
| 7116 | m4 := mload(0x80) |
| 7117 | // Selector of `log(bool,uint256,uint256,uint256)`. |
| 7118 | mstore(0x00, 0x374bb4b2) |
| 7119 | mstore(0x20, p0) |
| 7120 | mstore(0x40, p1) |
| 7121 | mstore(0x60, p2) |
| 7122 | mstore(0x80, p3) |
| 7123 | } |
| 7124 | _sendLogPayload(0x1c, 0x84); |
| 7125 | /// @solidity memory-safe-assembly |
| 7126 | assembly { |
| 7127 | mstore(0x00, m0) |
| 7128 | mstore(0x20, m1) |
| 7129 | mstore(0x40, m2) |
| 7130 | mstore(0x60, m3) |
| 7131 | mstore(0x80, m4) |
| 7132 | } |
| 7133 | } |
| 7134 | |
| 7135 | function log(bool p0, uint256 p1, uint256 p2, bytes32 p3) internal pure { |
| 7136 | bytes32 m0; |
| 7137 | bytes32 m1; |
| 7138 | bytes32 m2; |
| 7139 | bytes32 m3; |
| 7140 | bytes32 m4; |
| 7141 | bytes32 m5; |
| 7142 | bytes32 m6; |
| 7143 | /// @solidity memory-safe-assembly |
| 7144 | assembly { |
| 7145 | function writeString(pos, w) { |
| 7146 | let length := 0 |
| 7147 | for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } |
| 7148 | mstore(pos, length) |
| 7149 | let shift := sub(256, shl(3, length)) |
| 7150 | mstore(add(pos, 0x20), shl(shift, shr(shift, w))) |
| 7151 | } |
| 7152 | m0 := mload(0x00) |
| 7153 | m1 := mload(0x20) |
| 7154 | m2 := mload(0x40) |
| 7155 | m3 := mload(0x60) |
| 7156 | m4 := mload(0x80) |
| 7157 | m5 := mload(0xa0) |
| 7158 | m6 := mload(0xc0) |
| 7159 | // Selector of `log(bool,uint256,uint256,string)`. |
| 7160 | mstore(0x00, 0x8e69fb5d) |
| 7161 | mstore(0x20, p0) |
| 7162 | mstore(0x40, p1) |
| 7163 | mstore(0x60, p2) |
| 7164 | mstore(0x80, 0x80) |
| 7165 | writeString(0xa0, p3) |
| 7166 | } |
| 7167 | _sendLogPayload(0x1c, 0xc4); |
| 7168 | /// @solidity memory-safe-assembly |
| 7169 | assembly { |
| 7170 | mstore(0x00, m0) |
| 7171 | mstore(0x20, m1) |
| 7172 | mstore(0x40, m2) |
| 7173 | mstore(0x60, m3) |
| 7174 | mstore(0x80, m4) |
| 7175 | mstore(0xa0, m5) |
| 7176 | mstore(0xc0, m6) |
| 7177 | } |
| 7178 | } |
| 7179 | |
| 7180 | function log(bool p0, uint256 p1, bytes32 p2, address p3) internal pure { |
| 7181 | bytes32 m0; |
| 7182 | bytes32 m1; |
| 7183 | bytes32 m2; |
| 7184 | bytes32 m3; |
| 7185 | bytes32 m4; |
| 7186 | bytes32 m5; |
| 7187 | bytes32 m6; |
| 7188 | /// @solidity memory-safe-assembly |
| 7189 | assembly { |
| 7190 | function writeString(pos, w) { |
| 7191 | let length := 0 |
| 7192 | for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } |
| 7193 | mstore(pos, length) |
| 7194 | let shift := sub(256, shl(3, length)) |
| 7195 | mstore(add(pos, 0x20), shl(shift, shr(shift, w))) |
| 7196 | } |
| 7197 | m0 := mload(0x00) |
| 7198 | m1 := mload(0x20) |
| 7199 | m2 := mload(0x40) |
| 7200 | m3 := mload(0x60) |
| 7201 | m4 := mload(0x80) |
| 7202 | m5 := mload(0xa0) |
| 7203 | m6 := mload(0xc0) |
| 7204 | // Selector of `log(bool,uint256,string,address)`. |
| 7205 | mstore(0x00, 0xfedd1fff) |
| 7206 | mstore(0x20, p0) |
| 7207 | mstore(0x40, p1) |
| 7208 | mstore(0x60, 0x80) |
| 7209 | mstore(0x80, p3) |
| 7210 | writeString(0xa0, p2) |
| 7211 | } |
| 7212 | _sendLogPayload(0x1c, 0xc4); |
| 7213 | /// @solidity memory-safe-assembly |
| 7214 | assembly { |
| 7215 | mstore(0x00, m0) |
| 7216 | mstore(0x20, m1) |
| 7217 | mstore(0x40, m2) |
| 7218 | mstore(0x60, m3) |
| 7219 | mstore(0x80, m4) |
| 7220 | mstore(0xa0, m5) |
| 7221 | mstore(0xc0, m6) |
| 7222 | } |
| 7223 | } |
| 7224 | |
| 7225 | function log(bool p0, uint256 p1, bytes32 p2, bool p3) internal pure { |
| 7226 | bytes32 m0; |
| 7227 | bytes32 m1; |
| 7228 | bytes32 m2; |
| 7229 | bytes32 m3; |
| 7230 | bytes32 m4; |
| 7231 | bytes32 m5; |
| 7232 | bytes32 m6; |
| 7233 | /// @solidity memory-safe-assembly |
| 7234 | assembly { |
| 7235 | function writeString(pos, w) { |
| 7236 | let length := 0 |
| 7237 | for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } |
| 7238 | mstore(pos, length) |
| 7239 | let shift := sub(256, shl(3, length)) |
| 7240 | mstore(add(pos, 0x20), shl(shift, shr(shift, w))) |
| 7241 | } |
| 7242 | m0 := mload(0x00) |
| 7243 | m1 := mload(0x20) |
| 7244 | m2 := mload(0x40) |
| 7245 | m3 := mload(0x60) |
| 7246 | m4 := mload(0x80) |
| 7247 | m5 := mload(0xa0) |
| 7248 | m6 := mload(0xc0) |
| 7249 | // Selector of `log(bool,uint256,string,bool)`. |
| 7250 | mstore(0x00, 0xe5e70b2b) |
| 7251 | mstore(0x20, p0) |
| 7252 | mstore(0x40, p1) |
| 7253 | mstore(0x60, 0x80) |
| 7254 | mstore(0x80, p3) |
| 7255 | writeString(0xa0, p2) |
| 7256 | } |
| 7257 | _sendLogPayload(0x1c, 0xc4); |
| 7258 | /// @solidity memory-safe-assembly |
| 7259 | assembly { |
| 7260 | mstore(0x00, m0) |
| 7261 | mstore(0x20, m1) |
| 7262 | mstore(0x40, m2) |
| 7263 | mstore(0x60, m3) |
| 7264 | mstore(0x80, m4) |
| 7265 | mstore(0xa0, m5) |
| 7266 | mstore(0xc0, m6) |
| 7267 | } |
| 7268 | } |
| 7269 | |
| 7270 | function log(bool p0, uint256 p1, bytes32 p2, uint256 p3) internal pure { |
| 7271 | bytes32 m0; |
| 7272 | bytes32 m1; |
| 7273 | bytes32 m2; |
| 7274 | bytes32 m3; |
| 7275 | bytes32 m4; |
| 7276 | bytes32 m5; |
| 7277 | bytes32 m6; |
| 7278 | /// @solidity memory-safe-assembly |
| 7279 | assembly { |
| 7280 | function writeString(pos, w) { |
| 7281 | let length := 0 |
| 7282 | for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } |
| 7283 | mstore(pos, length) |
| 7284 | let shift := sub(256, shl(3, length)) |
| 7285 | mstore(add(pos, 0x20), shl(shift, shr(shift, w))) |
| 7286 | } |
| 7287 | m0 := mload(0x00) |
| 7288 | m1 := mload(0x20) |
| 7289 | m2 := mload(0x40) |
| 7290 | m3 := mload(0x60) |
| 7291 | m4 := mload(0x80) |
| 7292 | m5 := mload(0xa0) |
| 7293 | m6 := mload(0xc0) |
| 7294 | // Selector of `log(bool,uint256,string,uint256)`. |
| 7295 | mstore(0x00, 0x6a1199e2) |
| 7296 | mstore(0x20, p0) |
| 7297 | mstore(0x40, p1) |
| 7298 | mstore(0x60, 0x80) |
| 7299 | mstore(0x80, p3) |
| 7300 | writeString(0xa0, p2) |
| 7301 | } |
| 7302 | _sendLogPayload(0x1c, 0xc4); |
| 7303 | /// @solidity memory-safe-assembly |
| 7304 | assembly { |
| 7305 | mstore(0x00, m0) |
| 7306 | mstore(0x20, m1) |
| 7307 | mstore(0x40, m2) |
| 7308 | mstore(0x60, m3) |
| 7309 | mstore(0x80, m4) |
| 7310 | mstore(0xa0, m5) |
| 7311 | mstore(0xc0, m6) |
| 7312 | } |
| 7313 | } |
| 7314 | |
| 7315 | function log(bool p0, uint256 p1, bytes32 p2, bytes32 p3) internal pure { |
| 7316 | bytes32 m0; |
| 7317 | bytes32 m1; |
| 7318 | bytes32 m2; |
| 7319 | bytes32 m3; |
| 7320 | bytes32 m4; |
| 7321 | bytes32 m5; |
| 7322 | bytes32 m6; |
| 7323 | bytes32 m7; |
| 7324 | bytes32 m8; |
| 7325 | /// @solidity memory-safe-assembly |
| 7326 | assembly { |
| 7327 | function writeString(pos, w) { |
| 7328 | let length := 0 |
| 7329 | for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } |
| 7330 | mstore(pos, length) |
| 7331 | let shift := sub(256, shl(3, length)) |
| 7332 | mstore(add(pos, 0x20), shl(shift, shr(shift, w))) |
| 7333 | } |
| 7334 | m0 := mload(0x00) |
| 7335 | m1 := mload(0x20) |
| 7336 | m2 := mload(0x40) |
| 7337 | m3 := mload(0x60) |
| 7338 | m4 := mload(0x80) |
| 7339 | m5 := mload(0xa0) |
| 7340 | m6 := mload(0xc0) |
| 7341 | m7 := mload(0xe0) |
| 7342 | m8 := mload(0x100) |
| 7343 | // Selector of `log(bool,uint256,string,string)`. |
| 7344 | mstore(0x00, 0xf5bc2249) |
| 7345 | mstore(0x20, p0) |
| 7346 | mstore(0x40, p1) |
| 7347 | mstore(0x60, 0x80) |
| 7348 | mstore(0x80, 0xc0) |
| 7349 | writeString(0xa0, p2) |
| 7350 | writeString(0xe0, p3) |
| 7351 | } |
| 7352 | _sendLogPayload(0x1c, 0x104); |
| 7353 | /// @solidity memory-safe-assembly |
| 7354 | assembly { |
| 7355 | mstore(0x00, m0) |
| 7356 | mstore(0x20, m1) |
| 7357 | mstore(0x40, m2) |
| 7358 | mstore(0x60, m3) |
| 7359 | mstore(0x80, m4) |
| 7360 | mstore(0xa0, m5) |
| 7361 | mstore(0xc0, m6) |
| 7362 | mstore(0xe0, m7) |
| 7363 | mstore(0x100, m8) |
| 7364 | } |
| 7365 | } |
| 7366 | |
| 7367 | function log(bool p0, bytes32 p1, address p2, address p3) internal pure { |
| 7368 | bytes32 m0; |
| 7369 | bytes32 m1; |
| 7370 | bytes32 m2; |
| 7371 | bytes32 m3; |
| 7372 | bytes32 m4; |
| 7373 | bytes32 m5; |
| 7374 | bytes32 m6; |
| 7375 | /// @solidity memory-safe-assembly |
| 7376 | assembly { |
| 7377 | function writeString(pos, w) { |
| 7378 | let length := 0 |
| 7379 | for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } |
| 7380 | mstore(pos, length) |
| 7381 | let shift := sub(256, shl(3, length)) |
| 7382 | mstore(add(pos, 0x20), shl(shift, shr(shift, w))) |
| 7383 | } |
| 7384 | m0 := mload(0x00) |
| 7385 | m1 := mload(0x20) |
| 7386 | m2 := mload(0x40) |
| 7387 | m3 := mload(0x60) |
| 7388 | m4 := mload(0x80) |
| 7389 | m5 := mload(0xa0) |
| 7390 | m6 := mload(0xc0) |
| 7391 | // Selector of `log(bool,string,address,address)`. |
| 7392 | mstore(0x00, 0x2b2b18dc) |
| 7393 | mstore(0x20, p0) |
| 7394 | mstore(0x40, 0x80) |
| 7395 | mstore(0x60, p2) |
| 7396 | mstore(0x80, p3) |
| 7397 | writeString(0xa0, p1) |
| 7398 | } |
| 7399 | _sendLogPayload(0x1c, 0xc4); |
| 7400 | /// @solidity memory-safe-assembly |
| 7401 | assembly { |
| 7402 | mstore(0x00, m0) |
| 7403 | mstore(0x20, m1) |
| 7404 | mstore(0x40, m2) |
| 7405 | mstore(0x60, m3) |
| 7406 | mstore(0x80, m4) |
| 7407 | mstore(0xa0, m5) |
| 7408 | mstore(0xc0, m6) |
| 7409 | } |
| 7410 | } |
| 7411 | |
| 7412 | function log(bool p0, bytes32 p1, address p2, bool p3) internal pure { |
| 7413 | bytes32 m0; |
| 7414 | bytes32 m1; |
| 7415 | bytes32 m2; |
| 7416 | bytes32 m3; |
| 7417 | bytes32 m4; |
| 7418 | bytes32 m5; |
| 7419 | bytes32 m6; |
| 7420 | /// @solidity memory-safe-assembly |
| 7421 | assembly { |
| 7422 | function writeString(pos, w) { |
| 7423 | let length := 0 |
| 7424 | for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } |
| 7425 | mstore(pos, length) |
| 7426 | let shift := sub(256, shl(3, length)) |
| 7427 | mstore(add(pos, 0x20), shl(shift, shr(shift, w))) |
| 7428 | } |
| 7429 | m0 := mload(0x00) |
| 7430 | m1 := mload(0x20) |
| 7431 | m2 := mload(0x40) |
| 7432 | m3 := mload(0x60) |
| 7433 | m4 := mload(0x80) |
| 7434 | m5 := mload(0xa0) |
| 7435 | m6 := mload(0xc0) |
| 7436 | // Selector of `log(bool,string,address,bool)`. |
| 7437 | mstore(0x00, 0x6dd434ca) |
| 7438 | mstore(0x20, p0) |
| 7439 | mstore(0x40, 0x80) |
| 7440 | mstore(0x60, p2) |
| 7441 | mstore(0x80, p3) |
| 7442 | writeString(0xa0, p1) |
| 7443 | } |
| 7444 | _sendLogPayload(0x1c, 0xc4); |
| 7445 | /// @solidity memory-safe-assembly |
| 7446 | assembly { |
| 7447 | mstore(0x00, m0) |
| 7448 | mstore(0x20, m1) |
| 7449 | mstore(0x40, m2) |
| 7450 | mstore(0x60, m3) |
| 7451 | mstore(0x80, m4) |
| 7452 | mstore(0xa0, m5) |
| 7453 | mstore(0xc0, m6) |
| 7454 | } |
| 7455 | } |
| 7456 | |
| 7457 | function log(bool p0, bytes32 p1, address p2, uint256 p3) internal pure { |
| 7458 | bytes32 m0; |
| 7459 | bytes32 m1; |
| 7460 | bytes32 m2; |
| 7461 | bytes32 m3; |
| 7462 | bytes32 m4; |
| 7463 | bytes32 m5; |
| 7464 | bytes32 m6; |
| 7465 | /// @solidity memory-safe-assembly |
| 7466 | assembly { |
| 7467 | function writeString(pos, w) { |
| 7468 | let length := 0 |
| 7469 | for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } |
| 7470 | mstore(pos, length) |
| 7471 | let shift := sub(256, shl(3, length)) |
| 7472 | mstore(add(pos, 0x20), shl(shift, shr(shift, w))) |
| 7473 | } |
| 7474 | m0 := mload(0x00) |
| 7475 | m1 := mload(0x20) |
| 7476 | m2 := mload(0x40) |
| 7477 | m3 := mload(0x60) |
| 7478 | m4 := mload(0x80) |
| 7479 | m5 := mload(0xa0) |
| 7480 | m6 := mload(0xc0) |
| 7481 | // Selector of `log(bool,string,address,uint256)`. |
| 7482 | mstore(0x00, 0xa5cada94) |
| 7483 | mstore(0x20, p0) |
| 7484 | mstore(0x40, 0x80) |
| 7485 | mstore(0x60, p2) |
| 7486 | mstore(0x80, p3) |
| 7487 | writeString(0xa0, p1) |
| 7488 | } |
| 7489 | _sendLogPayload(0x1c, 0xc4); |
| 7490 | /// @solidity memory-safe-assembly |
| 7491 | assembly { |
| 7492 | mstore(0x00, m0) |
| 7493 | mstore(0x20, m1) |
| 7494 | mstore(0x40, m2) |
| 7495 | mstore(0x60, m3) |
| 7496 | mstore(0x80, m4) |
| 7497 | mstore(0xa0, m5) |
| 7498 | mstore(0xc0, m6) |
| 7499 | } |
| 7500 | } |
| 7501 | |
| 7502 | function log(bool p0, bytes32 p1, address p2, bytes32 p3) internal pure { |
| 7503 | bytes32 m0; |
| 7504 | bytes32 m1; |
| 7505 | bytes32 m2; |
| 7506 | bytes32 m3; |
| 7507 | bytes32 m4; |
| 7508 | bytes32 m5; |
| 7509 | bytes32 m6; |
| 7510 | bytes32 m7; |
| 7511 | bytes32 m8; |
| 7512 | /// @solidity memory-safe-assembly |
| 7513 | assembly { |
| 7514 | function writeString(pos, w) { |
| 7515 | let length := 0 |
| 7516 | for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } |
| 7517 | mstore(pos, length) |
| 7518 | let shift := sub(256, shl(3, length)) |
| 7519 | mstore(add(pos, 0x20), shl(shift, shr(shift, w))) |
| 7520 | } |
| 7521 | m0 := mload(0x00) |
| 7522 | m1 := mload(0x20) |
| 7523 | m2 := mload(0x40) |
| 7524 | m3 := mload(0x60) |
| 7525 | m4 := mload(0x80) |
| 7526 | m5 := mload(0xa0) |
| 7527 | m6 := mload(0xc0) |
| 7528 | m7 := mload(0xe0) |
| 7529 | m8 := mload(0x100) |
| 7530 | // Selector of `log(bool,string,address,string)`. |
| 7531 | mstore(0x00, 0x12d6c788) |
| 7532 | mstore(0x20, p0) |
| 7533 | mstore(0x40, 0x80) |
| 7534 | mstore(0x60, p2) |
| 7535 | mstore(0x80, 0xc0) |
| 7536 | writeString(0xa0, p1) |
| 7537 | writeString(0xe0, p3) |
| 7538 | } |
| 7539 | _sendLogPayload(0x1c, 0x104); |
| 7540 | /// @solidity memory-safe-assembly |
| 7541 | assembly { |
| 7542 | mstore(0x00, m0) |
| 7543 | mstore(0x20, m1) |
| 7544 | mstore(0x40, m2) |
| 7545 | mstore(0x60, m3) |
| 7546 | mstore(0x80, m4) |
| 7547 | mstore(0xa0, m5) |
| 7548 | mstore(0xc0, m6) |
| 7549 | mstore(0xe0, m7) |
| 7550 | mstore(0x100, m8) |
| 7551 | } |
| 7552 | } |
| 7553 | |
| 7554 | function log(bool p0, bytes32 p1, bool p2, address p3) internal pure { |
| 7555 | bytes32 m0; |
| 7556 | bytes32 m1; |
| 7557 | bytes32 m2; |
| 7558 | bytes32 m3; |
| 7559 | bytes32 m4; |
| 7560 | bytes32 m5; |
| 7561 | bytes32 m6; |
| 7562 | /// @solidity memory-safe-assembly |
| 7563 | assembly { |
| 7564 | function writeString(pos, w) { |
| 7565 | let length := 0 |
| 7566 | for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } |
| 7567 | mstore(pos, length) |
| 7568 | let shift := sub(256, shl(3, length)) |
| 7569 | mstore(add(pos, 0x20), shl(shift, shr(shift, w))) |
| 7570 | } |
| 7571 | m0 := mload(0x00) |
| 7572 | m1 := mload(0x20) |
| 7573 | m2 := mload(0x40) |
| 7574 | m3 := mload(0x60) |
| 7575 | m4 := mload(0x80) |
| 7576 | m5 := mload(0xa0) |
| 7577 | m6 := mload(0xc0) |
| 7578 | // Selector of `log(bool,string,bool,address)`. |
| 7579 | mstore(0x00, 0x538e06ab) |
| 7580 | mstore(0x20, p0) |
| 7581 | mstore(0x40, 0x80) |
| 7582 | mstore(0x60, p2) |
| 7583 | mstore(0x80, p3) |
| 7584 | writeString(0xa0, p1) |
| 7585 | } |
| 7586 | _sendLogPayload(0x1c, 0xc4); |
| 7587 | /// @solidity memory-safe-assembly |
| 7588 | assembly { |
| 7589 | mstore(0x00, m0) |
| 7590 | mstore(0x20, m1) |
| 7591 | mstore(0x40, m2) |
| 7592 | mstore(0x60, m3) |
| 7593 | mstore(0x80, m4) |
| 7594 | mstore(0xa0, m5) |
| 7595 | mstore(0xc0, m6) |
| 7596 | } |
| 7597 | } |
| 7598 | |
| 7599 | function log(bool p0, bytes32 p1, bool p2, bool p3) internal pure { |
| 7600 | bytes32 m0; |
| 7601 | bytes32 m1; |
| 7602 | bytes32 m2; |
| 7603 | bytes32 m3; |
| 7604 | bytes32 m4; |
| 7605 | bytes32 m5; |
| 7606 | bytes32 m6; |
| 7607 | /// @solidity memory-safe-assembly |
| 7608 | assembly { |
| 7609 | function writeString(pos, w) { |
| 7610 | let length := 0 |
| 7611 | for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } |
| 7612 | mstore(pos, length) |
| 7613 | let shift := sub(256, shl(3, length)) |
| 7614 | mstore(add(pos, 0x20), shl(shift, shr(shift, w))) |
| 7615 | } |
| 7616 | m0 := mload(0x00) |
| 7617 | m1 := mload(0x20) |
| 7618 | m2 := mload(0x40) |
| 7619 | m3 := mload(0x60) |
| 7620 | m4 := mload(0x80) |
| 7621 | m5 := mload(0xa0) |
| 7622 | m6 := mload(0xc0) |
| 7623 | // Selector of `log(bool,string,bool,bool)`. |
| 7624 | mstore(0x00, 0xdc5e935b) |
| 7625 | mstore(0x20, p0) |
| 7626 | mstore(0x40, 0x80) |
| 7627 | mstore(0x60, p2) |
| 7628 | mstore(0x80, p3) |
| 7629 | writeString(0xa0, p1) |
| 7630 | } |
| 7631 | _sendLogPayload(0x1c, 0xc4); |
| 7632 | /// @solidity memory-safe-assembly |
| 7633 | assembly { |
| 7634 | mstore(0x00, m0) |
| 7635 | mstore(0x20, m1) |
| 7636 | mstore(0x40, m2) |
| 7637 | mstore(0x60, m3) |
| 7638 | mstore(0x80, m4) |
| 7639 | mstore(0xa0, m5) |
| 7640 | mstore(0xc0, m6) |
| 7641 | } |
| 7642 | } |
| 7643 | |
| 7644 | function log(bool p0, bytes32 p1, bool p2, uint256 p3) internal pure { |
| 7645 | bytes32 m0; |
| 7646 | bytes32 m1; |
| 7647 | bytes32 m2; |
| 7648 | bytes32 m3; |
| 7649 | bytes32 m4; |
| 7650 | bytes32 m5; |
| 7651 | bytes32 m6; |
| 7652 | /// @solidity memory-safe-assembly |
| 7653 | assembly { |
| 7654 | function writeString(pos, w) { |
| 7655 | let length := 0 |
| 7656 | for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } |
| 7657 | mstore(pos, length) |
| 7658 | let shift := sub(256, shl(3, length)) |
| 7659 | mstore(add(pos, 0x20), shl(shift, shr(shift, w))) |
| 7660 | } |
| 7661 | m0 := mload(0x00) |
| 7662 | m1 := mload(0x20) |
| 7663 | m2 := mload(0x40) |
| 7664 | m3 := mload(0x60) |
| 7665 | m4 := mload(0x80) |
| 7666 | m5 := mload(0xa0) |
| 7667 | m6 := mload(0xc0) |
| 7668 | // Selector of `log(bool,string,bool,uint256)`. |
| 7669 | mstore(0x00, 0x1606a393) |
| 7670 | mstore(0x20, p0) |
| 7671 | mstore(0x40, 0x80) |
| 7672 | mstore(0x60, p2) |
| 7673 | mstore(0x80, p3) |
| 7674 | writeString(0xa0, p1) |
| 7675 | } |
| 7676 | _sendLogPayload(0x1c, 0xc4); |
| 7677 | /// @solidity memory-safe-assembly |
| 7678 | assembly { |
| 7679 | mstore(0x00, m0) |
| 7680 | mstore(0x20, m1) |
| 7681 | mstore(0x40, m2) |
| 7682 | mstore(0x60, m3) |
| 7683 | mstore(0x80, m4) |
| 7684 | mstore(0xa0, m5) |
| 7685 | mstore(0xc0, m6) |
| 7686 | } |
| 7687 | } |
| 7688 | |
| 7689 | function log(bool p0, bytes32 p1, bool p2, bytes32 p3) internal pure { |
| 7690 | bytes32 m0; |
| 7691 | bytes32 m1; |
| 7692 | bytes32 m2; |
| 7693 | bytes32 m3; |
| 7694 | bytes32 m4; |
| 7695 | bytes32 m5; |
| 7696 | bytes32 m6; |
| 7697 | bytes32 m7; |
| 7698 | bytes32 m8; |
| 7699 | /// @solidity memory-safe-assembly |
| 7700 | assembly { |
| 7701 | function writeString(pos, w) { |
| 7702 | let length := 0 |
| 7703 | for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } |
| 7704 | mstore(pos, length) |
| 7705 | let shift := sub(256, shl(3, length)) |
| 7706 | mstore(add(pos, 0x20), shl(shift, shr(shift, w))) |
| 7707 | } |
| 7708 | m0 := mload(0x00) |
| 7709 | m1 := mload(0x20) |
| 7710 | m2 := mload(0x40) |
| 7711 | m3 := mload(0x60) |
| 7712 | m4 := mload(0x80) |
| 7713 | m5 := mload(0xa0) |
| 7714 | m6 := mload(0xc0) |
| 7715 | m7 := mload(0xe0) |
| 7716 | m8 := mload(0x100) |
| 7717 | // Selector of `log(bool,string,bool,string)`. |
| 7718 | mstore(0x00, 0x483d0416) |
| 7719 | mstore(0x20, p0) |
| 7720 | mstore(0x40, 0x80) |
| 7721 | mstore(0x60, p2) |
| 7722 | mstore(0x80, 0xc0) |
| 7723 | writeString(0xa0, p1) |
| 7724 | writeString(0xe0, p3) |
| 7725 | } |
| 7726 | _sendLogPayload(0x1c, 0x104); |
| 7727 | /// @solidity memory-safe-assembly |
| 7728 | assembly { |
| 7729 | mstore(0x00, m0) |
| 7730 | mstore(0x20, m1) |
| 7731 | mstore(0x40, m2) |
| 7732 | mstore(0x60, m3) |
| 7733 | mstore(0x80, m4) |
| 7734 | mstore(0xa0, m5) |
| 7735 | mstore(0xc0, m6) |
| 7736 | mstore(0xe0, m7) |
| 7737 | mstore(0x100, m8) |
| 7738 | } |
| 7739 | } |
| 7740 | |
| 7741 | function log(bool p0, bytes32 p1, uint256 p2, address p3) internal pure { |
| 7742 | bytes32 m0; |
| 7743 | bytes32 m1; |
| 7744 | bytes32 m2; |
| 7745 | bytes32 m3; |
| 7746 | bytes32 m4; |
| 7747 | bytes32 m5; |
| 7748 | bytes32 m6; |
| 7749 | /// @solidity memory-safe-assembly |
| 7750 | assembly { |
| 7751 | function writeString(pos, w) { |
| 7752 | let length := 0 |
| 7753 | for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } |
| 7754 | mstore(pos, length) |
| 7755 | let shift := sub(256, shl(3, length)) |
| 7756 | mstore(add(pos, 0x20), shl(shift, shr(shift, w))) |
| 7757 | } |
| 7758 | m0 := mload(0x00) |
| 7759 | m1 := mload(0x20) |
| 7760 | m2 := mload(0x40) |
| 7761 | m3 := mload(0x60) |
| 7762 | m4 := mload(0x80) |
| 7763 | m5 := mload(0xa0) |
| 7764 | m6 := mload(0xc0) |
| 7765 | // Selector of `log(bool,string,uint256,address)`. |
| 7766 | mstore(0x00, 0x1596a1ce) |
| 7767 | mstore(0x20, p0) |
| 7768 | mstore(0x40, 0x80) |
| 7769 | mstore(0x60, p2) |
| 7770 | mstore(0x80, p3) |
| 7771 | writeString(0xa0, p1) |
| 7772 | } |
| 7773 | _sendLogPayload(0x1c, 0xc4); |
| 7774 | /// @solidity memory-safe-assembly |
| 7775 | assembly { |
| 7776 | mstore(0x00, m0) |
| 7777 | mstore(0x20, m1) |
| 7778 | mstore(0x40, m2) |
| 7779 | mstore(0x60, m3) |
| 7780 | mstore(0x80, m4) |
| 7781 | mstore(0xa0, m5) |
| 7782 | mstore(0xc0, m6) |
| 7783 | } |
| 7784 | } |
| 7785 | |
| 7786 | function log(bool p0, bytes32 p1, uint256 p2, bool p3) internal pure { |
| 7787 | bytes32 m0; |
| 7788 | bytes32 m1; |
| 7789 | bytes32 m2; |
| 7790 | bytes32 m3; |
| 7791 | bytes32 m4; |
| 7792 | bytes32 m5; |
| 7793 | bytes32 m6; |
| 7794 | /// @solidity memory-safe-assembly |
| 7795 | assembly { |
| 7796 | function writeString(pos, w) { |
| 7797 | let length := 0 |
| 7798 | for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } |
| 7799 | mstore(pos, length) |
| 7800 | let shift := sub(256, shl(3, length)) |
| 7801 | mstore(add(pos, 0x20), shl(shift, shr(shift, w))) |
| 7802 | } |
| 7803 | m0 := mload(0x00) |
| 7804 | m1 := mload(0x20) |
| 7805 | m2 := mload(0x40) |
| 7806 | m3 := mload(0x60) |
| 7807 | m4 := mload(0x80) |
| 7808 | m5 := mload(0xa0) |
| 7809 | m6 := mload(0xc0) |
| 7810 | // Selector of `log(bool,string,uint256,bool)`. |
| 7811 | mstore(0x00, 0x6b0e5d53) |
| 7812 | mstore(0x20, p0) |
| 7813 | mstore(0x40, 0x80) |
| 7814 | mstore(0x60, p2) |
| 7815 | mstore(0x80, p3) |
| 7816 | writeString(0xa0, p1) |
| 7817 | } |
| 7818 | _sendLogPayload(0x1c, 0xc4); |
| 7819 | /// @solidity memory-safe-assembly |
| 7820 | assembly { |
| 7821 | mstore(0x00, m0) |
| 7822 | mstore(0x20, m1) |
| 7823 | mstore(0x40, m2) |
| 7824 | mstore(0x60, m3) |
| 7825 | mstore(0x80, m4) |
| 7826 | mstore(0xa0, m5) |
| 7827 | mstore(0xc0, m6) |
| 7828 | } |
| 7829 | } |
| 7830 | |
| 7831 | function log(bool p0, bytes32 p1, uint256 p2, uint256 p3) internal pure { |
| 7832 | bytes32 m0; |
| 7833 | bytes32 m1; |
| 7834 | bytes32 m2; |
| 7835 | bytes32 m3; |
| 7836 | bytes32 m4; |
| 7837 | bytes32 m5; |
| 7838 | bytes32 m6; |
| 7839 | /// @solidity memory-safe-assembly |
| 7840 | assembly { |
| 7841 | function writeString(pos, w) { |
| 7842 | let length := 0 |
| 7843 | for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } |
| 7844 | mstore(pos, length) |
| 7845 | let shift := sub(256, shl(3, length)) |
| 7846 | mstore(add(pos, 0x20), shl(shift, shr(shift, w))) |
| 7847 | } |
| 7848 | m0 := mload(0x00) |
| 7849 | m1 := mload(0x20) |
| 7850 | m2 := mload(0x40) |
| 7851 | m3 := mload(0x60) |
| 7852 | m4 := mload(0x80) |
| 7853 | m5 := mload(0xa0) |
| 7854 | m6 := mload(0xc0) |
| 7855 | // Selector of `log(bool,string,uint256,uint256)`. |
| 7856 | mstore(0x00, 0x28863fcb) |
| 7857 | mstore(0x20, p0) |
| 7858 | mstore(0x40, 0x80) |
| 7859 | mstore(0x60, p2) |
| 7860 | mstore(0x80, p3) |
| 7861 | writeString(0xa0, p1) |
| 7862 | } |
| 7863 | _sendLogPayload(0x1c, 0xc4); |
| 7864 | /// @solidity memory-safe-assembly |
| 7865 | assembly { |
| 7866 | mstore(0x00, m0) |
| 7867 | mstore(0x20, m1) |
| 7868 | mstore(0x40, m2) |
| 7869 | mstore(0x60, m3) |
| 7870 | mstore(0x80, m4) |
| 7871 | mstore(0xa0, m5) |
| 7872 | mstore(0xc0, m6) |
| 7873 | } |
| 7874 | } |
| 7875 | |
| 7876 | function log(bool p0, bytes32 p1, uint256 p2, bytes32 p3) internal pure { |
| 7877 | bytes32 m0; |
| 7878 | bytes32 m1; |
| 7879 | bytes32 m2; |
| 7880 | bytes32 m3; |
| 7881 | bytes32 m4; |
| 7882 | bytes32 m5; |
| 7883 | bytes32 m6; |
| 7884 | bytes32 m7; |
| 7885 | bytes32 m8; |
| 7886 | /// @solidity memory-safe-assembly |
| 7887 | assembly { |
| 7888 | function writeString(pos, w) { |
| 7889 | let length := 0 |
| 7890 | for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } |
| 7891 | mstore(pos, length) |
| 7892 | let shift := sub(256, shl(3, length)) |
| 7893 | mstore(add(pos, 0x20), shl(shift, shr(shift, w))) |
| 7894 | } |
| 7895 | m0 := mload(0x00) |
| 7896 | m1 := mload(0x20) |
| 7897 | m2 := mload(0x40) |
| 7898 | m3 := mload(0x60) |
| 7899 | m4 := mload(0x80) |
| 7900 | m5 := mload(0xa0) |
| 7901 | m6 := mload(0xc0) |
| 7902 | m7 := mload(0xe0) |
| 7903 | m8 := mload(0x100) |
| 7904 | // Selector of `log(bool,string,uint256,string)`. |
| 7905 | mstore(0x00, 0x1ad96de6) |
| 7906 | mstore(0x20, p0) |
| 7907 | mstore(0x40, 0x80) |
| 7908 | mstore(0x60, p2) |
| 7909 | mstore(0x80, 0xc0) |
| 7910 | writeString(0xa0, p1) |
| 7911 | writeString(0xe0, p3) |
| 7912 | } |
| 7913 | _sendLogPayload(0x1c, 0x104); |
| 7914 | /// @solidity memory-safe-assembly |
| 7915 | assembly { |
| 7916 | mstore(0x00, m0) |
| 7917 | mstore(0x20, m1) |
| 7918 | mstore(0x40, m2) |
| 7919 | mstore(0x60, m3) |
| 7920 | mstore(0x80, m4) |
| 7921 | mstore(0xa0, m5) |
| 7922 | mstore(0xc0, m6) |
| 7923 | mstore(0xe0, m7) |
| 7924 | mstore(0x100, m8) |
| 7925 | } |
| 7926 | } |
| 7927 | |
| 7928 | function log(bool p0, bytes32 p1, bytes32 p2, address p3) internal pure { |
| 7929 | bytes32 m0; |
| 7930 | bytes32 m1; |
| 7931 | bytes32 m2; |
| 7932 | bytes32 m3; |
| 7933 | bytes32 m4; |
| 7934 | bytes32 m5; |
| 7935 | bytes32 m6; |
| 7936 | bytes32 m7; |
| 7937 | bytes32 m8; |
| 7938 | /// @solidity memory-safe-assembly |
| 7939 | assembly { |
| 7940 | function writeString(pos, w) { |
| 7941 | let length := 0 |
| 7942 | for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } |
| 7943 | mstore(pos, length) |
| 7944 | let shift := sub(256, shl(3, length)) |
| 7945 | mstore(add(pos, 0x20), shl(shift, shr(shift, w))) |
| 7946 | } |
| 7947 | m0 := mload(0x00) |
| 7948 | m1 := mload(0x20) |
| 7949 | m2 := mload(0x40) |
| 7950 | m3 := mload(0x60) |
| 7951 | m4 := mload(0x80) |
| 7952 | m5 := mload(0xa0) |
| 7953 | m6 := mload(0xc0) |
| 7954 | m7 := mload(0xe0) |
| 7955 | m8 := mload(0x100) |
| 7956 | // Selector of `log(bool,string,string,address)`. |
| 7957 | mstore(0x00, 0x97d394d8) |
| 7958 | mstore(0x20, p0) |
| 7959 | mstore(0x40, 0x80) |
| 7960 | mstore(0x60, 0xc0) |
| 7961 | mstore(0x80, p3) |
| 7962 | writeString(0xa0, p1) |
| 7963 | writeString(0xe0, p2) |
| 7964 | } |
| 7965 | _sendLogPayload(0x1c, 0x104); |
| 7966 | /// @solidity memory-safe-assembly |
| 7967 | assembly { |
| 7968 | mstore(0x00, m0) |
| 7969 | mstore(0x20, m1) |
| 7970 | mstore(0x40, m2) |
| 7971 | mstore(0x60, m3) |
| 7972 | mstore(0x80, m4) |
| 7973 | mstore(0xa0, m5) |
| 7974 | mstore(0xc0, m6) |
| 7975 | mstore(0xe0, m7) |
| 7976 | mstore(0x100, m8) |
| 7977 | } |
| 7978 | } |
| 7979 | |
| 7980 | function log(bool p0, bytes32 p1, bytes32 p2, bool p3) internal pure { |
| 7981 | bytes32 m0; |
| 7982 | bytes32 m1; |
| 7983 | bytes32 m2; |
| 7984 | bytes32 m3; |
| 7985 | bytes32 m4; |
| 7986 | bytes32 m5; |
| 7987 | bytes32 m6; |
| 7988 | bytes32 m7; |
| 7989 | bytes32 m8; |
| 7990 | /// @solidity memory-safe-assembly |
| 7991 | assembly { |
| 7992 | function writeString(pos, w) { |
| 7993 | let length := 0 |
| 7994 | for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } |
| 7995 | mstore(pos, length) |
| 7996 | let shift := sub(256, shl(3, length)) |
| 7997 | mstore(add(pos, 0x20), shl(shift, shr(shift, w))) |
| 7998 | } |
| 7999 | m0 := mload(0x00) |
| 8000 | m1 := mload(0x20) |
| 8001 | m2 := mload(0x40) |
| 8002 | m3 := mload(0x60) |
| 8003 | m4 := mload(0x80) |
| 8004 | m5 := mload(0xa0) |
| 8005 | m6 := mload(0xc0) |
| 8006 | m7 := mload(0xe0) |
| 8007 | m8 := mload(0x100) |
| 8008 | // Selector of `log(bool,string,string,bool)`. |
| 8009 | mstore(0x00, 0x1e4b87e5) |
| 8010 | mstore(0x20, p0) |
| 8011 | mstore(0x40, 0x80) |
| 8012 | mstore(0x60, 0xc0) |
| 8013 | mstore(0x80, p3) |
| 8014 | writeString(0xa0, p1) |
| 8015 | writeString(0xe0, p2) |
| 8016 | } |
| 8017 | _sendLogPayload(0x1c, 0x104); |
| 8018 | /// @solidity memory-safe-assembly |
| 8019 | assembly { |
| 8020 | mstore(0x00, m0) |
| 8021 | mstore(0x20, m1) |
| 8022 | mstore(0x40, m2) |
| 8023 | mstore(0x60, m3) |
| 8024 | mstore(0x80, m4) |
| 8025 | mstore(0xa0, m5) |
| 8026 | mstore(0xc0, m6) |
| 8027 | mstore(0xe0, m7) |
| 8028 | mstore(0x100, m8) |
| 8029 | } |
| 8030 | } |
| 8031 | |
| 8032 | function log(bool p0, bytes32 p1, bytes32 p2, uint256 p3) internal pure { |
| 8033 | bytes32 m0; |
| 8034 | bytes32 m1; |
| 8035 | bytes32 m2; |
| 8036 | bytes32 m3; |
| 8037 | bytes32 m4; |
| 8038 | bytes32 m5; |
| 8039 | bytes32 m6; |
| 8040 | bytes32 m7; |
| 8041 | bytes32 m8; |
| 8042 | /// @solidity memory-safe-assembly |
| 8043 | assembly { |
| 8044 | function writeString(pos, w) { |
| 8045 | let length := 0 |
| 8046 | for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } |
| 8047 | mstore(pos, length) |
| 8048 | let shift := sub(256, shl(3, length)) |
| 8049 | mstore(add(pos, 0x20), shl(shift, shr(shift, w))) |
| 8050 | } |
| 8051 | m0 := mload(0x00) |
| 8052 | m1 := mload(0x20) |
| 8053 | m2 := mload(0x40) |
| 8054 | m3 := mload(0x60) |
| 8055 | m4 := mload(0x80) |
| 8056 | m5 := mload(0xa0) |
| 8057 | m6 := mload(0xc0) |
| 8058 | m7 := mload(0xe0) |
| 8059 | m8 := mload(0x100) |
| 8060 | // Selector of `log(bool,string,string,uint256)`. |
| 8061 | mstore(0x00, 0x7be0c3eb) |
| 8062 | mstore(0x20, p0) |
| 8063 | mstore(0x40, 0x80) |
| 8064 | mstore(0x60, 0xc0) |
| 8065 | mstore(0x80, p3) |
| 8066 | writeString(0xa0, p1) |
| 8067 | writeString(0xe0, p2) |
| 8068 | } |
| 8069 | _sendLogPayload(0x1c, 0x104); |
| 8070 | /// @solidity memory-safe-assembly |
| 8071 | assembly { |
| 8072 | mstore(0x00, m0) |
| 8073 | mstore(0x20, m1) |
| 8074 | mstore(0x40, m2) |
| 8075 | mstore(0x60, m3) |
| 8076 | mstore(0x80, m4) |
| 8077 | mstore(0xa0, m5) |
| 8078 | mstore(0xc0, m6) |
| 8079 | mstore(0xe0, m7) |
| 8080 | mstore(0x100, m8) |
| 8081 | } |
| 8082 | } |
| 8083 | |
| 8084 | function log(bool p0, bytes32 p1, bytes32 p2, bytes32 p3) internal pure { |
| 8085 | bytes32 m0; |
| 8086 | bytes32 m1; |
| 8087 | bytes32 m2; |
| 8088 | bytes32 m3; |
| 8089 | bytes32 m4; |
| 8090 | bytes32 m5; |
| 8091 | bytes32 m6; |
| 8092 | bytes32 m7; |
| 8093 | bytes32 m8; |
| 8094 | bytes32 m9; |
| 8095 | bytes32 m10; |
| 8096 | /// @solidity memory-safe-assembly |
| 8097 | assembly { |
| 8098 | function writeString(pos, w) { |
| 8099 | let length := 0 |
| 8100 | for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } |
| 8101 | mstore(pos, length) |
| 8102 | let shift := sub(256, shl(3, length)) |
| 8103 | mstore(add(pos, 0x20), shl(shift, shr(shift, w))) |
| 8104 | } |
| 8105 | m0 := mload(0x00) |
| 8106 | m1 := mload(0x20) |
| 8107 | m2 := mload(0x40) |
| 8108 | m3 := mload(0x60) |
| 8109 | m4 := mload(0x80) |
| 8110 | m5 := mload(0xa0) |
| 8111 | m6 := mload(0xc0) |
| 8112 | m7 := mload(0xe0) |
| 8113 | m8 := mload(0x100) |
| 8114 | m9 := mload(0x120) |
| 8115 | m10 := mload(0x140) |
| 8116 | // Selector of `log(bool,string,string,string)`. |
| 8117 | mstore(0x00, 0x1762e32a) |
| 8118 | mstore(0x20, p0) |
| 8119 | mstore(0x40, 0x80) |
| 8120 | mstore(0x60, 0xc0) |
| 8121 | mstore(0x80, 0x100) |
| 8122 | writeString(0xa0, p1) |
| 8123 | writeString(0xe0, p2) |
| 8124 | writeString(0x120, p3) |
| 8125 | } |
| 8126 | _sendLogPayload(0x1c, 0x144); |
| 8127 | /// @solidity memory-safe-assembly |
| 8128 | assembly { |
| 8129 | mstore(0x00, m0) |
| 8130 | mstore(0x20, m1) |
| 8131 | mstore(0x40, m2) |
| 8132 | mstore(0x60, m3) |
| 8133 | mstore(0x80, m4) |
| 8134 | mstore(0xa0, m5) |
| 8135 | mstore(0xc0, m6) |
| 8136 | mstore(0xe0, m7) |
| 8137 | mstore(0x100, m8) |
| 8138 | mstore(0x120, m9) |
| 8139 | mstore(0x140, m10) |
| 8140 | } |
| 8141 | } |
| 8142 | |
| 8143 | function log(uint256 p0, address p1, address p2, address p3) internal pure { |
| 8144 | bytes32 m0; |
| 8145 | bytes32 m1; |
| 8146 | bytes32 m2; |
| 8147 | bytes32 m3; |
| 8148 | bytes32 m4; |
| 8149 | /// @solidity memory-safe-assembly |
| 8150 | assembly { |
| 8151 | m0 := mload(0x00) |
| 8152 | m1 := mload(0x20) |
| 8153 | m2 := mload(0x40) |
| 8154 | m3 := mload(0x60) |
| 8155 | m4 := mload(0x80) |
| 8156 | // Selector of `log(uint256,address,address,address)`. |
| 8157 | mstore(0x00, 0x2488b414) |
| 8158 | mstore(0x20, p0) |
| 8159 | mstore(0x40, p1) |
| 8160 | mstore(0x60, p2) |
| 8161 | mstore(0x80, p3) |
| 8162 | } |
| 8163 | _sendLogPayload(0x1c, 0x84); |
| 8164 | /// @solidity memory-safe-assembly |
| 8165 | assembly { |
| 8166 | mstore(0x00, m0) |
| 8167 | mstore(0x20, m1) |
| 8168 | mstore(0x40, m2) |
| 8169 | mstore(0x60, m3) |
| 8170 | mstore(0x80, m4) |
| 8171 | } |
| 8172 | } |
| 8173 | |
| 8174 | function log(uint256 p0, address p1, address p2, bool p3) internal pure { |
| 8175 | bytes32 m0; |
| 8176 | bytes32 m1; |
| 8177 | bytes32 m2; |
| 8178 | bytes32 m3; |
| 8179 | bytes32 m4; |
| 8180 | /// @solidity memory-safe-assembly |
| 8181 | assembly { |
| 8182 | m0 := mload(0x00) |
| 8183 | m1 := mload(0x20) |
| 8184 | m2 := mload(0x40) |
| 8185 | m3 := mload(0x60) |
| 8186 | m4 := mload(0x80) |
| 8187 | // Selector of `log(uint256,address,address,bool)`. |
| 8188 | mstore(0x00, 0x091ffaf5) |
| 8189 | mstore(0x20, p0) |
| 8190 | mstore(0x40, p1) |
| 8191 | mstore(0x60, p2) |
| 8192 | mstore(0x80, p3) |
| 8193 | } |
| 8194 | _sendLogPayload(0x1c, 0x84); |
| 8195 | /// @solidity memory-safe-assembly |
| 8196 | assembly { |
| 8197 | mstore(0x00, m0) |
| 8198 | mstore(0x20, m1) |
| 8199 | mstore(0x40, m2) |
| 8200 | mstore(0x60, m3) |
| 8201 | mstore(0x80, m4) |
| 8202 | } |
| 8203 | } |
| 8204 | |
| 8205 | function log(uint256 p0, address p1, address p2, uint256 p3) internal pure { |
| 8206 | bytes32 m0; |
| 8207 | bytes32 m1; |
| 8208 | bytes32 m2; |
| 8209 | bytes32 m3; |
| 8210 | bytes32 m4; |
| 8211 | /// @solidity memory-safe-assembly |
| 8212 | assembly { |
| 8213 | m0 := mload(0x00) |
| 8214 | m1 := mload(0x20) |
| 8215 | m2 := mload(0x40) |
| 8216 | m3 := mload(0x60) |
| 8217 | m4 := mload(0x80) |
| 8218 | // Selector of `log(uint256,address,address,uint256)`. |
| 8219 | mstore(0x00, 0x736efbb6) |
| 8220 | mstore(0x20, p0) |
| 8221 | mstore(0x40, p1) |
| 8222 | mstore(0x60, p2) |
| 8223 | mstore(0x80, p3) |
| 8224 | } |
| 8225 | _sendLogPayload(0x1c, 0x84); |
| 8226 | /// @solidity memory-safe-assembly |
| 8227 | assembly { |
| 8228 | mstore(0x00, m0) |
| 8229 | mstore(0x20, m1) |
| 8230 | mstore(0x40, m2) |
| 8231 | mstore(0x60, m3) |
| 8232 | mstore(0x80, m4) |
| 8233 | } |
| 8234 | } |
| 8235 | |
| 8236 | function log(uint256 p0, address p1, address p2, bytes32 p3) internal pure { |
| 8237 | bytes32 m0; |
| 8238 | bytes32 m1; |
| 8239 | bytes32 m2; |
| 8240 | bytes32 m3; |
| 8241 | bytes32 m4; |
| 8242 | bytes32 m5; |
| 8243 | bytes32 m6; |
| 8244 | /// @solidity memory-safe-assembly |
| 8245 | assembly { |
| 8246 | function writeString(pos, w) { |
| 8247 | let length := 0 |
| 8248 | for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } |
| 8249 | mstore(pos, length) |
| 8250 | let shift := sub(256, shl(3, length)) |
| 8251 | mstore(add(pos, 0x20), shl(shift, shr(shift, w))) |
| 8252 | } |
| 8253 | m0 := mload(0x00) |
| 8254 | m1 := mload(0x20) |
| 8255 | m2 := mload(0x40) |
| 8256 | m3 := mload(0x60) |
| 8257 | m4 := mload(0x80) |
| 8258 | m5 := mload(0xa0) |
| 8259 | m6 := mload(0xc0) |
| 8260 | // Selector of `log(uint256,address,address,string)`. |
| 8261 | mstore(0x00, 0x031c6f73) |
| 8262 | mstore(0x20, p0) |
| 8263 | mstore(0x40, p1) |
| 8264 | mstore(0x60, p2) |
| 8265 | mstore(0x80, 0x80) |
| 8266 | writeString(0xa0, p3) |
| 8267 | } |
| 8268 | _sendLogPayload(0x1c, 0xc4); |
| 8269 | /// @solidity memory-safe-assembly |
| 8270 | assembly { |
| 8271 | mstore(0x00, m0) |
| 8272 | mstore(0x20, m1) |
| 8273 | mstore(0x40, m2) |
| 8274 | mstore(0x60, m3) |
| 8275 | mstore(0x80, m4) |
| 8276 | mstore(0xa0, m5) |
| 8277 | mstore(0xc0, m6) |
| 8278 | } |
| 8279 | } |
| 8280 | |
| 8281 | function log(uint256 p0, address p1, bool p2, address p3) internal pure { |
| 8282 | bytes32 m0; |
| 8283 | bytes32 m1; |
| 8284 | bytes32 m2; |
| 8285 | bytes32 m3; |
| 8286 | bytes32 m4; |
| 8287 | /// @solidity memory-safe-assembly |
| 8288 | assembly { |
| 8289 | m0 := mload(0x00) |
| 8290 | m1 := mload(0x20) |
| 8291 | m2 := mload(0x40) |
| 8292 | m3 := mload(0x60) |
| 8293 | m4 := mload(0x80) |
| 8294 | // Selector of `log(uint256,address,bool,address)`. |
| 8295 | mstore(0x00, 0xef72c513) |
| 8296 | mstore(0x20, p0) |
| 8297 | mstore(0x40, p1) |
| 8298 | mstore(0x60, p2) |
| 8299 | mstore(0x80, p3) |
| 8300 | } |
| 8301 | _sendLogPayload(0x1c, 0x84); |
| 8302 | /// @solidity memory-safe-assembly |
| 8303 | assembly { |
| 8304 | mstore(0x00, m0) |
| 8305 | mstore(0x20, m1) |
| 8306 | mstore(0x40, m2) |
| 8307 | mstore(0x60, m3) |
| 8308 | mstore(0x80, m4) |
| 8309 | } |
| 8310 | } |
| 8311 | |
| 8312 | function log(uint256 p0, address p1, bool p2, bool p3) internal pure { |
| 8313 | bytes32 m0; |
| 8314 | bytes32 m1; |
| 8315 | bytes32 m2; |
| 8316 | bytes32 m3; |
| 8317 | bytes32 m4; |
| 8318 | /// @solidity memory-safe-assembly |
| 8319 | assembly { |
| 8320 | m0 := mload(0x00) |
| 8321 | m1 := mload(0x20) |
| 8322 | m2 := mload(0x40) |
| 8323 | m3 := mload(0x60) |
| 8324 | m4 := mload(0x80) |
| 8325 | // Selector of `log(uint256,address,bool,bool)`. |
| 8326 | mstore(0x00, 0xe351140f) |
| 8327 | mstore(0x20, p0) |
| 8328 | mstore(0x40, p1) |
| 8329 | mstore(0x60, p2) |
| 8330 | mstore(0x80, p3) |
| 8331 | } |
| 8332 | _sendLogPayload(0x1c, 0x84); |
| 8333 | /// @solidity memory-safe-assembly |
| 8334 | assembly { |
| 8335 | mstore(0x00, m0) |
| 8336 | mstore(0x20, m1) |
| 8337 | mstore(0x40, m2) |
| 8338 | mstore(0x60, m3) |
| 8339 | mstore(0x80, m4) |
| 8340 | } |
| 8341 | } |
| 8342 | |
| 8343 | function log(uint256 p0, address p1, bool p2, uint256 p3) internal pure { |
| 8344 | bytes32 m0; |
| 8345 | bytes32 m1; |
| 8346 | bytes32 m2; |
| 8347 | bytes32 m3; |
| 8348 | bytes32 m4; |
| 8349 | /// @solidity memory-safe-assembly |
| 8350 | assembly { |
| 8351 | m0 := mload(0x00) |
| 8352 | m1 := mload(0x20) |
| 8353 | m2 := mload(0x40) |
| 8354 | m3 := mload(0x60) |
| 8355 | m4 := mload(0x80) |
| 8356 | // Selector of `log(uint256,address,bool,uint256)`. |
| 8357 | mstore(0x00, 0x5abd992a) |
| 8358 | mstore(0x20, p0) |
| 8359 | mstore(0x40, p1) |
| 8360 | mstore(0x60, p2) |
| 8361 | mstore(0x80, p3) |
| 8362 | } |
| 8363 | _sendLogPayload(0x1c, 0x84); |
| 8364 | /// @solidity memory-safe-assembly |
| 8365 | assembly { |
| 8366 | mstore(0x00, m0) |
| 8367 | mstore(0x20, m1) |
| 8368 | mstore(0x40, m2) |
| 8369 | mstore(0x60, m3) |
| 8370 | mstore(0x80, m4) |
| 8371 | } |
| 8372 | } |
| 8373 | |
| 8374 | function log(uint256 p0, address p1, bool p2, bytes32 p3) internal pure { |
| 8375 | bytes32 m0; |
| 8376 | bytes32 m1; |
| 8377 | bytes32 m2; |
| 8378 | bytes32 m3; |
| 8379 | bytes32 m4; |
| 8380 | bytes32 m5; |
| 8381 | bytes32 m6; |
| 8382 | /// @solidity memory-safe-assembly |
| 8383 | assembly { |
| 8384 | function writeString(pos, w) { |
| 8385 | let length := 0 |
| 8386 | for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } |
| 8387 | mstore(pos, length) |
| 8388 | let shift := sub(256, shl(3, length)) |
| 8389 | mstore(add(pos, 0x20), shl(shift, shr(shift, w))) |
| 8390 | } |
| 8391 | m0 := mload(0x00) |
| 8392 | m1 := mload(0x20) |
| 8393 | m2 := mload(0x40) |
| 8394 | m3 := mload(0x60) |
| 8395 | m4 := mload(0x80) |
| 8396 | m5 := mload(0xa0) |
| 8397 | m6 := mload(0xc0) |
| 8398 | // Selector of `log(uint256,address,bool,string)`. |
| 8399 | mstore(0x00, 0x90fb06aa) |
| 8400 | mstore(0x20, p0) |
| 8401 | mstore(0x40, p1) |
| 8402 | mstore(0x60, p2) |
| 8403 | mstore(0x80, 0x80) |
| 8404 | writeString(0xa0, p3) |
| 8405 | } |
| 8406 | _sendLogPayload(0x1c, 0xc4); |
| 8407 | /// @solidity memory-safe-assembly |
| 8408 | assembly { |
| 8409 | mstore(0x00, m0) |
| 8410 | mstore(0x20, m1) |
| 8411 | mstore(0x40, m2) |
| 8412 | mstore(0x60, m3) |
| 8413 | mstore(0x80, m4) |
| 8414 | mstore(0xa0, m5) |
| 8415 | mstore(0xc0, m6) |
| 8416 | } |
| 8417 | } |
| 8418 | |
| 8419 | function log(uint256 p0, address p1, uint256 p2, address p3) internal pure { |
| 8420 | bytes32 m0; |
| 8421 | bytes32 m1; |
| 8422 | bytes32 m2; |
| 8423 | bytes32 m3; |
| 8424 | bytes32 m4; |
| 8425 | /// @solidity memory-safe-assembly |
| 8426 | assembly { |
| 8427 | m0 := mload(0x00) |
| 8428 | m1 := mload(0x20) |
| 8429 | m2 := mload(0x40) |
| 8430 | m3 := mload(0x60) |
| 8431 | m4 := mload(0x80) |
| 8432 | // Selector of `log(uint256,address,uint256,address)`. |
| 8433 | mstore(0x00, 0x15c127b5) |
| 8434 | mstore(0x20, p0) |
| 8435 | mstore(0x40, p1) |
| 8436 | mstore(0x60, p2) |
| 8437 | mstore(0x80, p3) |
| 8438 | } |
| 8439 | _sendLogPayload(0x1c, 0x84); |
| 8440 | /// @solidity memory-safe-assembly |
| 8441 | assembly { |
| 8442 | mstore(0x00, m0) |
| 8443 | mstore(0x20, m1) |
| 8444 | mstore(0x40, m2) |
| 8445 | mstore(0x60, m3) |
| 8446 | mstore(0x80, m4) |
| 8447 | } |
| 8448 | } |
| 8449 | |
| 8450 | function log(uint256 p0, address p1, uint256 p2, bool p3) internal pure { |
| 8451 | bytes32 m0; |
| 8452 | bytes32 m1; |
| 8453 | bytes32 m2; |
| 8454 | bytes32 m3; |
| 8455 | bytes32 m4; |
| 8456 | /// @solidity memory-safe-assembly |
| 8457 | assembly { |
| 8458 | m0 := mload(0x00) |
| 8459 | m1 := mload(0x20) |
| 8460 | m2 := mload(0x40) |
| 8461 | m3 := mload(0x60) |
| 8462 | m4 := mload(0x80) |
| 8463 | // Selector of `log(uint256,address,uint256,bool)`. |
| 8464 | mstore(0x00, 0x5f743a7c) |
| 8465 | mstore(0x20, p0) |
| 8466 | mstore(0x40, p1) |
| 8467 | mstore(0x60, p2) |
| 8468 | mstore(0x80, p3) |
| 8469 | } |
| 8470 | _sendLogPayload(0x1c, 0x84); |
| 8471 | /// @solidity memory-safe-assembly |
| 8472 | assembly { |
| 8473 | mstore(0x00, m0) |
| 8474 | mstore(0x20, m1) |
| 8475 | mstore(0x40, m2) |
| 8476 | mstore(0x60, m3) |
| 8477 | mstore(0x80, m4) |
| 8478 | } |
| 8479 | } |
| 8480 | |
| 8481 | function log(uint256 p0, address p1, uint256 p2, uint256 p3) internal pure { |
| 8482 | bytes32 m0; |
| 8483 | bytes32 m1; |
| 8484 | bytes32 m2; |
| 8485 | bytes32 m3; |
| 8486 | bytes32 m4; |
| 8487 | /// @solidity memory-safe-assembly |
| 8488 | assembly { |
| 8489 | m0 := mload(0x00) |
| 8490 | m1 := mload(0x20) |
| 8491 | m2 := mload(0x40) |
| 8492 | m3 := mload(0x60) |
| 8493 | m4 := mload(0x80) |
| 8494 | // Selector of `log(uint256,address,uint256,uint256)`. |
| 8495 | mstore(0x00, 0x0c9cd9c1) |
| 8496 | mstore(0x20, p0) |
| 8497 | mstore(0x40, p1) |
| 8498 | mstore(0x60, p2) |
| 8499 | mstore(0x80, p3) |
| 8500 | } |
| 8501 | _sendLogPayload(0x1c, 0x84); |
| 8502 | /// @solidity memory-safe-assembly |
| 8503 | assembly { |
| 8504 | mstore(0x00, m0) |
| 8505 | mstore(0x20, m1) |
| 8506 | mstore(0x40, m2) |
| 8507 | mstore(0x60, m3) |
| 8508 | mstore(0x80, m4) |
| 8509 | } |
| 8510 | } |
| 8511 | |
| 8512 | function log(uint256 p0, address p1, uint256 p2, bytes32 p3) internal pure { |
| 8513 | bytes32 m0; |
| 8514 | bytes32 m1; |
| 8515 | bytes32 m2; |
| 8516 | bytes32 m3; |
| 8517 | bytes32 m4; |
| 8518 | bytes32 m5; |
| 8519 | bytes32 m6; |
| 8520 | /// @solidity memory-safe-assembly |
| 8521 | assembly { |
| 8522 | function writeString(pos, w) { |
| 8523 | let length := 0 |
| 8524 | for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } |
| 8525 | mstore(pos, length) |
| 8526 | let shift := sub(256, shl(3, length)) |
| 8527 | mstore(add(pos, 0x20), shl(shift, shr(shift, w))) |
| 8528 | } |
| 8529 | m0 := mload(0x00) |
| 8530 | m1 := mload(0x20) |
| 8531 | m2 := mload(0x40) |
| 8532 | m3 := mload(0x60) |
| 8533 | m4 := mload(0x80) |
| 8534 | m5 := mload(0xa0) |
| 8535 | m6 := mload(0xc0) |
| 8536 | // Selector of `log(uint256,address,uint256,string)`. |
| 8537 | mstore(0x00, 0xddb06521) |
| 8538 | mstore(0x20, p0) |
| 8539 | mstore(0x40, p1) |
| 8540 | mstore(0x60, p2) |
| 8541 | mstore(0x80, 0x80) |
| 8542 | writeString(0xa0, p3) |
| 8543 | } |
| 8544 | _sendLogPayload(0x1c, 0xc4); |
| 8545 | /// @solidity memory-safe-assembly |
| 8546 | assembly { |
| 8547 | mstore(0x00, m0) |
| 8548 | mstore(0x20, m1) |
| 8549 | mstore(0x40, m2) |
| 8550 | mstore(0x60, m3) |
| 8551 | mstore(0x80, m4) |
| 8552 | mstore(0xa0, m5) |
| 8553 | mstore(0xc0, m6) |
| 8554 | } |
| 8555 | } |
| 8556 | |
| 8557 | function log(uint256 p0, address p1, bytes32 p2, address p3) internal pure { |
| 8558 | bytes32 m0; |
| 8559 | bytes32 m1; |
| 8560 | bytes32 m2; |
| 8561 | bytes32 m3; |
| 8562 | bytes32 m4; |
| 8563 | bytes32 m5; |
| 8564 | bytes32 m6; |
| 8565 | /// @solidity memory-safe-assembly |
| 8566 | assembly { |
| 8567 | function writeString(pos, w) { |
| 8568 | let length := 0 |
| 8569 | for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } |
| 8570 | mstore(pos, length) |
| 8571 | let shift := sub(256, shl(3, length)) |
| 8572 | mstore(add(pos, 0x20), shl(shift, shr(shift, w))) |
| 8573 | } |
| 8574 | m0 := mload(0x00) |
| 8575 | m1 := mload(0x20) |
| 8576 | m2 := mload(0x40) |
| 8577 | m3 := mload(0x60) |
| 8578 | m4 := mload(0x80) |
| 8579 | m5 := mload(0xa0) |
| 8580 | m6 := mload(0xc0) |
| 8581 | // Selector of `log(uint256,address,string,address)`. |
| 8582 | mstore(0x00, 0x9cba8fff) |
| 8583 | mstore(0x20, p0) |
| 8584 | mstore(0x40, p1) |
| 8585 | mstore(0x60, 0x80) |
| 8586 | mstore(0x80, p3) |
| 8587 | writeString(0xa0, p2) |
| 8588 | } |
| 8589 | _sendLogPayload(0x1c, 0xc4); |
| 8590 | /// @solidity memory-safe-assembly |
| 8591 | assembly { |
| 8592 | mstore(0x00, m0) |
| 8593 | mstore(0x20, m1) |
| 8594 | mstore(0x40, m2) |
| 8595 | mstore(0x60, m3) |
| 8596 | mstore(0x80, m4) |
| 8597 | mstore(0xa0, m5) |
| 8598 | mstore(0xc0, m6) |
| 8599 | } |
| 8600 | } |
| 8601 | |
| 8602 | function log(uint256 p0, address p1, bytes32 p2, bool p3) internal pure { |
| 8603 | bytes32 m0; |
| 8604 | bytes32 m1; |
| 8605 | bytes32 m2; |
| 8606 | bytes32 m3; |
| 8607 | bytes32 m4; |
| 8608 | bytes32 m5; |
| 8609 | bytes32 m6; |
| 8610 | /// @solidity memory-safe-assembly |
| 8611 | assembly { |
| 8612 | function writeString(pos, w) { |
| 8613 | let length := 0 |
| 8614 | for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } |
| 8615 | mstore(pos, length) |
| 8616 | let shift := sub(256, shl(3, length)) |
| 8617 | mstore(add(pos, 0x20), shl(shift, shr(shift, w))) |
| 8618 | } |
| 8619 | m0 := mload(0x00) |
| 8620 | m1 := mload(0x20) |
| 8621 | m2 := mload(0x40) |
| 8622 | m3 := mload(0x60) |
| 8623 | m4 := mload(0x80) |
| 8624 | m5 := mload(0xa0) |
| 8625 | m6 := mload(0xc0) |
| 8626 | // Selector of `log(uint256,address,string,bool)`. |
| 8627 | mstore(0x00, 0xcc32ab07) |
| 8628 | mstore(0x20, p0) |
| 8629 | mstore(0x40, p1) |
| 8630 | mstore(0x60, 0x80) |
| 8631 | mstore(0x80, p3) |
| 8632 | writeString(0xa0, p2) |
| 8633 | } |
| 8634 | _sendLogPayload(0x1c, 0xc4); |
| 8635 | /// @solidity memory-safe-assembly |
| 8636 | assembly { |
| 8637 | mstore(0x00, m0) |
| 8638 | mstore(0x20, m1) |
| 8639 | mstore(0x40, m2) |
| 8640 | mstore(0x60, m3) |
| 8641 | mstore(0x80, m4) |
| 8642 | mstore(0xa0, m5) |
| 8643 | mstore(0xc0, m6) |
| 8644 | } |
| 8645 | } |
| 8646 | |
| 8647 | function log(uint256 p0, address p1, bytes32 p2, uint256 p3) internal pure { |
| 8648 | bytes32 m0; |
| 8649 | bytes32 m1; |
| 8650 | bytes32 m2; |
| 8651 | bytes32 m3; |
| 8652 | bytes32 m4; |
| 8653 | bytes32 m5; |
| 8654 | bytes32 m6; |
| 8655 | /// @solidity memory-safe-assembly |
| 8656 | assembly { |
| 8657 | function writeString(pos, w) { |
| 8658 | let length := 0 |
| 8659 | for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } |
| 8660 | mstore(pos, length) |
| 8661 | let shift := sub(256, shl(3, length)) |
| 8662 | mstore(add(pos, 0x20), shl(shift, shr(shift, w))) |
| 8663 | } |
| 8664 | m0 := mload(0x00) |
| 8665 | m1 := mload(0x20) |
| 8666 | m2 := mload(0x40) |
| 8667 | m3 := mload(0x60) |
| 8668 | m4 := mload(0x80) |
| 8669 | m5 := mload(0xa0) |
| 8670 | m6 := mload(0xc0) |
| 8671 | // Selector of `log(uint256,address,string,uint256)`. |
| 8672 | mstore(0x00, 0x46826b5d) |
| 8673 | mstore(0x20, p0) |
| 8674 | mstore(0x40, p1) |
| 8675 | mstore(0x60, 0x80) |
| 8676 | mstore(0x80, p3) |
| 8677 | writeString(0xa0, p2) |
| 8678 | } |
| 8679 | _sendLogPayload(0x1c, 0xc4); |
| 8680 | /// @solidity memory-safe-assembly |
| 8681 | assembly { |
| 8682 | mstore(0x00, m0) |
| 8683 | mstore(0x20, m1) |
| 8684 | mstore(0x40, m2) |
| 8685 | mstore(0x60, m3) |
| 8686 | mstore(0x80, m4) |
| 8687 | mstore(0xa0, m5) |
| 8688 | mstore(0xc0, m6) |
| 8689 | } |
| 8690 | } |
| 8691 | |
| 8692 | function log(uint256 p0, address p1, bytes32 p2, bytes32 p3) internal pure { |
| 8693 | bytes32 m0; |
| 8694 | bytes32 m1; |
| 8695 | bytes32 m2; |
| 8696 | bytes32 m3; |
| 8697 | bytes32 m4; |
| 8698 | bytes32 m5; |
| 8699 | bytes32 m6; |
| 8700 | bytes32 m7; |
| 8701 | bytes32 m8; |
| 8702 | /// @solidity memory-safe-assembly |
| 8703 | assembly { |
| 8704 | function writeString(pos, w) { |
| 8705 | let length := 0 |
| 8706 | for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } |
| 8707 | mstore(pos, length) |
| 8708 | let shift := sub(256, shl(3, length)) |
| 8709 | mstore(add(pos, 0x20), shl(shift, shr(shift, w))) |
| 8710 | } |
| 8711 | m0 := mload(0x00) |
| 8712 | m1 := mload(0x20) |
| 8713 | m2 := mload(0x40) |
| 8714 | m3 := mload(0x60) |
| 8715 | m4 := mload(0x80) |
| 8716 | m5 := mload(0xa0) |
| 8717 | m6 := mload(0xc0) |
| 8718 | m7 := mload(0xe0) |
| 8719 | m8 := mload(0x100) |
| 8720 | // Selector of `log(uint256,address,string,string)`. |
| 8721 | mstore(0x00, 0x3e128ca3) |
| 8722 | mstore(0x20, p0) |
| 8723 | mstore(0x40, p1) |
| 8724 | mstore(0x60, 0x80) |
| 8725 | mstore(0x80, 0xc0) |
| 8726 | writeString(0xa0, p2) |
| 8727 | writeString(0xe0, p3) |
| 8728 | } |
| 8729 | _sendLogPayload(0x1c, 0x104); |
| 8730 | /// @solidity memory-safe-assembly |
| 8731 | assembly { |
| 8732 | mstore(0x00, m0) |
| 8733 | mstore(0x20, m1) |
| 8734 | mstore(0x40, m2) |
| 8735 | mstore(0x60, m3) |
| 8736 | mstore(0x80, m4) |
| 8737 | mstore(0xa0, m5) |
| 8738 | mstore(0xc0, m6) |
| 8739 | mstore(0xe0, m7) |
| 8740 | mstore(0x100, m8) |
| 8741 | } |
| 8742 | } |
| 8743 | |
| 8744 | function log(uint256 p0, bool p1, address p2, address p3) internal pure { |
| 8745 | bytes32 m0; |
| 8746 | bytes32 m1; |
| 8747 | bytes32 m2; |
| 8748 | bytes32 m3; |
| 8749 | bytes32 m4; |
| 8750 | /// @solidity memory-safe-assembly |
| 8751 | assembly { |
| 8752 | m0 := mload(0x00) |
| 8753 | m1 := mload(0x20) |
| 8754 | m2 := mload(0x40) |
| 8755 | m3 := mload(0x60) |
| 8756 | m4 := mload(0x80) |
| 8757 | // Selector of `log(uint256,bool,address,address)`. |
| 8758 | mstore(0x00, 0xa1ef4cbb) |
| 8759 | mstore(0x20, p0) |
| 8760 | mstore(0x40, p1) |
| 8761 | mstore(0x60, p2) |
| 8762 | mstore(0x80, p3) |
| 8763 | } |
| 8764 | _sendLogPayload(0x1c, 0x84); |
| 8765 | /// @solidity memory-safe-assembly |
| 8766 | assembly { |
| 8767 | mstore(0x00, m0) |
| 8768 | mstore(0x20, m1) |
| 8769 | mstore(0x40, m2) |
| 8770 | mstore(0x60, m3) |
| 8771 | mstore(0x80, m4) |
| 8772 | } |
| 8773 | } |
| 8774 | |
| 8775 | function log(uint256 p0, bool p1, address p2, bool p3) internal pure { |
| 8776 | bytes32 m0; |
| 8777 | bytes32 m1; |
| 8778 | bytes32 m2; |
| 8779 | bytes32 m3; |
| 8780 | bytes32 m4; |
| 8781 | /// @solidity memory-safe-assembly |
| 8782 | assembly { |
| 8783 | m0 := mload(0x00) |
| 8784 | m1 := mload(0x20) |
| 8785 | m2 := mload(0x40) |
| 8786 | m3 := mload(0x60) |
| 8787 | m4 := mload(0x80) |
| 8788 | // Selector of `log(uint256,bool,address,bool)`. |
| 8789 | mstore(0x00, 0x454d54a5) |
| 8790 | mstore(0x20, p0) |
| 8791 | mstore(0x40, p1) |
| 8792 | mstore(0x60, p2) |
| 8793 | mstore(0x80, p3) |
| 8794 | } |
| 8795 | _sendLogPayload(0x1c, 0x84); |
| 8796 | /// @solidity memory-safe-assembly |
| 8797 | assembly { |
| 8798 | mstore(0x00, m0) |
| 8799 | mstore(0x20, m1) |
| 8800 | mstore(0x40, m2) |
| 8801 | mstore(0x60, m3) |
| 8802 | mstore(0x80, m4) |
| 8803 | } |
| 8804 | } |
| 8805 | |
| 8806 | function log(uint256 p0, bool p1, address p2, uint256 p3) internal pure { |
| 8807 | bytes32 m0; |
| 8808 | bytes32 m1; |
| 8809 | bytes32 m2; |
| 8810 | bytes32 m3; |
| 8811 | bytes32 m4; |
| 8812 | /// @solidity memory-safe-assembly |
| 8813 | assembly { |
| 8814 | m0 := mload(0x00) |
| 8815 | m1 := mload(0x20) |
| 8816 | m2 := mload(0x40) |
| 8817 | m3 := mload(0x60) |
| 8818 | m4 := mload(0x80) |
| 8819 | // Selector of `log(uint256,bool,address,uint256)`. |
| 8820 | mstore(0x00, 0x078287f5) |
| 8821 | mstore(0x20, p0) |
| 8822 | mstore(0x40, p1) |
| 8823 | mstore(0x60, p2) |
| 8824 | mstore(0x80, p3) |
| 8825 | } |
| 8826 | _sendLogPayload(0x1c, 0x84); |
| 8827 | /// @solidity memory-safe-assembly |
| 8828 | assembly { |
| 8829 | mstore(0x00, m0) |
| 8830 | mstore(0x20, m1) |
| 8831 | mstore(0x40, m2) |
| 8832 | mstore(0x60, m3) |
| 8833 | mstore(0x80, m4) |
| 8834 | } |
| 8835 | } |
| 8836 | |
| 8837 | function log(uint256 p0, bool p1, address p2, bytes32 p3) internal pure { |
| 8838 | bytes32 m0; |
| 8839 | bytes32 m1; |
| 8840 | bytes32 m2; |
| 8841 | bytes32 m3; |
| 8842 | bytes32 m4; |
| 8843 | bytes32 m5; |
| 8844 | bytes32 m6; |
| 8845 | /// @solidity memory-safe-assembly |
| 8846 | assembly { |
| 8847 | function writeString(pos, w) { |
| 8848 | let length := 0 |
| 8849 | for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } |
| 8850 | mstore(pos, length) |
| 8851 | let shift := sub(256, shl(3, length)) |
| 8852 | mstore(add(pos, 0x20), shl(shift, shr(shift, w))) |
| 8853 | } |
| 8854 | m0 := mload(0x00) |
| 8855 | m1 := mload(0x20) |
| 8856 | m2 := mload(0x40) |
| 8857 | m3 := mload(0x60) |
| 8858 | m4 := mload(0x80) |
| 8859 | m5 := mload(0xa0) |
| 8860 | m6 := mload(0xc0) |
| 8861 | // Selector of `log(uint256,bool,address,string)`. |
| 8862 | mstore(0x00, 0xade052c7) |
| 8863 | mstore(0x20, p0) |
| 8864 | mstore(0x40, p1) |
| 8865 | mstore(0x60, p2) |
| 8866 | mstore(0x80, 0x80) |
| 8867 | writeString(0xa0, p3) |
| 8868 | } |
| 8869 | _sendLogPayload(0x1c, 0xc4); |
| 8870 | /// @solidity memory-safe-assembly |
| 8871 | assembly { |
| 8872 | mstore(0x00, m0) |
| 8873 | mstore(0x20, m1) |
| 8874 | mstore(0x40, m2) |
| 8875 | mstore(0x60, m3) |
| 8876 | mstore(0x80, m4) |
| 8877 | mstore(0xa0, m5) |
| 8878 | mstore(0xc0, m6) |
| 8879 | } |
| 8880 | } |
| 8881 | |
| 8882 | function log(uint256 p0, bool p1, bool p2, address p3) internal pure { |
| 8883 | bytes32 m0; |
| 8884 | bytes32 m1; |
| 8885 | bytes32 m2; |
| 8886 | bytes32 m3; |
| 8887 | bytes32 m4; |
| 8888 | /// @solidity memory-safe-assembly |
| 8889 | assembly { |
| 8890 | m0 := mload(0x00) |
| 8891 | m1 := mload(0x20) |
| 8892 | m2 := mload(0x40) |
| 8893 | m3 := mload(0x60) |
| 8894 | m4 := mload(0x80) |
| 8895 | // Selector of `log(uint256,bool,bool,address)`. |
| 8896 | mstore(0x00, 0x69640b59) |
| 8897 | mstore(0x20, p0) |
| 8898 | mstore(0x40, p1) |
| 8899 | mstore(0x60, p2) |
| 8900 | mstore(0x80, p3) |
| 8901 | } |
| 8902 | _sendLogPayload(0x1c, 0x84); |
| 8903 | /// @solidity memory-safe-assembly |
| 8904 | assembly { |
| 8905 | mstore(0x00, m0) |
| 8906 | mstore(0x20, m1) |
| 8907 | mstore(0x40, m2) |
| 8908 | mstore(0x60, m3) |
| 8909 | mstore(0x80, m4) |
| 8910 | } |
| 8911 | } |
| 8912 | |
| 8913 | function log(uint256 p0, bool p1, bool p2, bool p3) internal pure { |
| 8914 | bytes32 m0; |
| 8915 | bytes32 m1; |
| 8916 | bytes32 m2; |
| 8917 | bytes32 m3; |
| 8918 | bytes32 m4; |
| 8919 | /// @solidity memory-safe-assembly |
| 8920 | assembly { |
| 8921 | m0 := mload(0x00) |
| 8922 | m1 := mload(0x20) |
| 8923 | m2 := mload(0x40) |
| 8924 | m3 := mload(0x60) |
| 8925 | m4 := mload(0x80) |
| 8926 | // Selector of `log(uint256,bool,bool,bool)`. |
| 8927 | mstore(0x00, 0xb6f577a1) |
| 8928 | mstore(0x20, p0) |
| 8929 | mstore(0x40, p1) |
| 8930 | mstore(0x60, p2) |
| 8931 | mstore(0x80, p3) |
| 8932 | } |
| 8933 | _sendLogPayload(0x1c, 0x84); |
| 8934 | /// @solidity memory-safe-assembly |
| 8935 | assembly { |
| 8936 | mstore(0x00, m0) |
| 8937 | mstore(0x20, m1) |
| 8938 | mstore(0x40, m2) |
| 8939 | mstore(0x60, m3) |
| 8940 | mstore(0x80, m4) |
| 8941 | } |
| 8942 | } |
| 8943 | |
| 8944 | function log(uint256 p0, bool p1, bool p2, uint256 p3) internal pure { |
| 8945 | bytes32 m0; |
| 8946 | bytes32 m1; |
| 8947 | bytes32 m2; |
| 8948 | bytes32 m3; |
| 8949 | bytes32 m4; |
| 8950 | /// @solidity memory-safe-assembly |
| 8951 | assembly { |
| 8952 | m0 := mload(0x00) |
| 8953 | m1 := mload(0x20) |
| 8954 | m2 := mload(0x40) |
| 8955 | m3 := mload(0x60) |
| 8956 | m4 := mload(0x80) |
| 8957 | // Selector of `log(uint256,bool,bool,uint256)`. |
| 8958 | mstore(0x00, 0x7464ce23) |
| 8959 | mstore(0x20, p0) |
| 8960 | mstore(0x40, p1) |
| 8961 | mstore(0x60, p2) |
| 8962 | mstore(0x80, p3) |
| 8963 | } |
| 8964 | _sendLogPayload(0x1c, 0x84); |
| 8965 | /// @solidity memory-safe-assembly |
| 8966 | assembly { |
| 8967 | mstore(0x00, m0) |
| 8968 | mstore(0x20, m1) |
| 8969 | mstore(0x40, m2) |
| 8970 | mstore(0x60, m3) |
| 8971 | mstore(0x80, m4) |
| 8972 | } |
| 8973 | } |
| 8974 | |
| 8975 | function log(uint256 p0, bool p1, bool p2, bytes32 p3) internal pure { |
| 8976 | bytes32 m0; |
| 8977 | bytes32 m1; |
| 8978 | bytes32 m2; |
| 8979 | bytes32 m3; |
| 8980 | bytes32 m4; |
| 8981 | bytes32 m5; |
| 8982 | bytes32 m6; |
| 8983 | /// @solidity memory-safe-assembly |
| 8984 | assembly { |
| 8985 | function writeString(pos, w) { |
| 8986 | let length := 0 |
| 8987 | for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } |
| 8988 | mstore(pos, length) |
| 8989 | let shift := sub(256, shl(3, length)) |
| 8990 | mstore(add(pos, 0x20), shl(shift, shr(shift, w))) |
| 8991 | } |
| 8992 | m0 := mload(0x00) |
| 8993 | m1 := mload(0x20) |
| 8994 | m2 := mload(0x40) |
| 8995 | m3 := mload(0x60) |
| 8996 | m4 := mload(0x80) |
| 8997 | m5 := mload(0xa0) |
| 8998 | m6 := mload(0xc0) |
| 8999 | // Selector of `log(uint256,bool,bool,string)`. |
| 9000 | mstore(0x00, 0xdddb9561) |
| 9001 | mstore(0x20, p0) |
| 9002 | mstore(0x40, p1) |
| 9003 | mstore(0x60, p2) |
| 9004 | mstore(0x80, 0x80) |
| 9005 | writeString(0xa0, p3) |
| 9006 | } |
| 9007 | _sendLogPayload(0x1c, 0xc4); |
| 9008 | /// @solidity memory-safe-assembly |
| 9009 | assembly { |
| 9010 | mstore(0x00, m0) |
| 9011 | mstore(0x20, m1) |
| 9012 | mstore(0x40, m2) |
| 9013 | mstore(0x60, m3) |
| 9014 | mstore(0x80, m4) |
| 9015 | mstore(0xa0, m5) |
| 9016 | mstore(0xc0, m6) |
| 9017 | } |
| 9018 | } |
| 9019 | |
| 9020 | function log(uint256 p0, bool p1, uint256 p2, address p3) internal pure { |
| 9021 | bytes32 m0; |
| 9022 | bytes32 m1; |
| 9023 | bytes32 m2; |
| 9024 | bytes32 m3; |
| 9025 | bytes32 m4; |
| 9026 | /// @solidity memory-safe-assembly |
| 9027 | assembly { |
| 9028 | m0 := mload(0x00) |
| 9029 | m1 := mload(0x20) |
| 9030 | m2 := mload(0x40) |
| 9031 | m3 := mload(0x60) |
| 9032 | m4 := mload(0x80) |
| 9033 | // Selector of `log(uint256,bool,uint256,address)`. |
| 9034 | mstore(0x00, 0x88cb6041) |
| 9035 | mstore(0x20, p0) |
| 9036 | mstore(0x40, p1) |
| 9037 | mstore(0x60, p2) |
| 9038 | mstore(0x80, p3) |
| 9039 | } |
| 9040 | _sendLogPayload(0x1c, 0x84); |
| 9041 | /// @solidity memory-safe-assembly |
| 9042 | assembly { |
| 9043 | mstore(0x00, m0) |
| 9044 | mstore(0x20, m1) |
| 9045 | mstore(0x40, m2) |
| 9046 | mstore(0x60, m3) |
| 9047 | mstore(0x80, m4) |
| 9048 | } |
| 9049 | } |
| 9050 | |
| 9051 | function log(uint256 p0, bool p1, uint256 p2, bool p3) internal pure { |
| 9052 | bytes32 m0; |
| 9053 | bytes32 m1; |
| 9054 | bytes32 m2; |
| 9055 | bytes32 m3; |
| 9056 | bytes32 m4; |
| 9057 | /// @solidity memory-safe-assembly |
| 9058 | assembly { |
| 9059 | m0 := mload(0x00) |
| 9060 | m1 := mload(0x20) |
| 9061 | m2 := mload(0x40) |
| 9062 | m3 := mload(0x60) |
| 9063 | m4 := mload(0x80) |
| 9064 | // Selector of `log(uint256,bool,uint256,bool)`. |
| 9065 | mstore(0x00, 0x91a02e2a) |
| 9066 | mstore(0x20, p0) |
| 9067 | mstore(0x40, p1) |
| 9068 | mstore(0x60, p2) |
| 9069 | mstore(0x80, p3) |
| 9070 | } |
| 9071 | _sendLogPayload(0x1c, 0x84); |
| 9072 | /// @solidity memory-safe-assembly |
| 9073 | assembly { |
| 9074 | mstore(0x00, m0) |
| 9075 | mstore(0x20, m1) |
| 9076 | mstore(0x40, m2) |
| 9077 | mstore(0x60, m3) |
| 9078 | mstore(0x80, m4) |
| 9079 | } |
| 9080 | } |
| 9081 | |
| 9082 | function log(uint256 p0, bool p1, uint256 p2, uint256 p3) internal pure { |
| 9083 | bytes32 m0; |
| 9084 | bytes32 m1; |
| 9085 | bytes32 m2; |
| 9086 | bytes32 m3; |
| 9087 | bytes32 m4; |
| 9088 | /// @solidity memory-safe-assembly |
| 9089 | assembly { |
| 9090 | m0 := mload(0x00) |
| 9091 | m1 := mload(0x20) |
| 9092 | m2 := mload(0x40) |
| 9093 | m3 := mload(0x60) |
| 9094 | m4 := mload(0x80) |
| 9095 | // Selector of `log(uint256,bool,uint256,uint256)`. |
| 9096 | mstore(0x00, 0xc6acc7a8) |
| 9097 | mstore(0x20, p0) |
| 9098 | mstore(0x40, p1) |
| 9099 | mstore(0x60, p2) |
| 9100 | mstore(0x80, p3) |
| 9101 | } |
| 9102 | _sendLogPayload(0x1c, 0x84); |
| 9103 | /// @solidity memory-safe-assembly |
| 9104 | assembly { |
| 9105 | mstore(0x00, m0) |
| 9106 | mstore(0x20, m1) |
| 9107 | mstore(0x40, m2) |
| 9108 | mstore(0x60, m3) |
| 9109 | mstore(0x80, m4) |
| 9110 | } |
| 9111 | } |
| 9112 | |
| 9113 | function log(uint256 p0, bool p1, uint256 p2, bytes32 p3) internal pure { |
| 9114 | bytes32 m0; |
| 9115 | bytes32 m1; |
| 9116 | bytes32 m2; |
| 9117 | bytes32 m3; |
| 9118 | bytes32 m4; |
| 9119 | bytes32 m5; |
| 9120 | bytes32 m6; |
| 9121 | /// @solidity memory-safe-assembly |
| 9122 | assembly { |
| 9123 | function writeString(pos, w) { |
| 9124 | let length := 0 |
| 9125 | for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } |
| 9126 | mstore(pos, length) |
| 9127 | let shift := sub(256, shl(3, length)) |
| 9128 | mstore(add(pos, 0x20), shl(shift, shr(shift, w))) |
| 9129 | } |
| 9130 | m0 := mload(0x00) |
| 9131 | m1 := mload(0x20) |
| 9132 | m2 := mload(0x40) |
| 9133 | m3 := mload(0x60) |
| 9134 | m4 := mload(0x80) |
| 9135 | m5 := mload(0xa0) |
| 9136 | m6 := mload(0xc0) |
| 9137 | // Selector of `log(uint256,bool,uint256,string)`. |
| 9138 | mstore(0x00, 0xde03e774) |
| 9139 | mstore(0x20, p0) |
| 9140 | mstore(0x40, p1) |
| 9141 | mstore(0x60, p2) |
| 9142 | mstore(0x80, 0x80) |
| 9143 | writeString(0xa0, p3) |
| 9144 | } |
| 9145 | _sendLogPayload(0x1c, 0xc4); |
| 9146 | /// @solidity memory-safe-assembly |
| 9147 | assembly { |
| 9148 | mstore(0x00, m0) |
| 9149 | mstore(0x20, m1) |
| 9150 | mstore(0x40, m2) |
| 9151 | mstore(0x60, m3) |
| 9152 | mstore(0x80, m4) |
| 9153 | mstore(0xa0, m5) |
| 9154 | mstore(0xc0, m6) |
| 9155 | } |
| 9156 | } |
| 9157 | |
| 9158 | function log(uint256 p0, bool p1, bytes32 p2, address p3) internal pure { |
| 9159 | bytes32 m0; |
| 9160 | bytes32 m1; |
| 9161 | bytes32 m2; |
| 9162 | bytes32 m3; |
| 9163 | bytes32 m4; |
| 9164 | bytes32 m5; |
| 9165 | bytes32 m6; |
| 9166 | /// @solidity memory-safe-assembly |
| 9167 | assembly { |
| 9168 | function writeString(pos, w) { |
| 9169 | let length := 0 |
| 9170 | for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } |
| 9171 | mstore(pos, length) |
| 9172 | let shift := sub(256, shl(3, length)) |
| 9173 | mstore(add(pos, 0x20), shl(shift, shr(shift, w))) |
| 9174 | } |
| 9175 | m0 := mload(0x00) |
| 9176 | m1 := mload(0x20) |
| 9177 | m2 := mload(0x40) |
| 9178 | m3 := mload(0x60) |
| 9179 | m4 := mload(0x80) |
| 9180 | m5 := mload(0xa0) |
| 9181 | m6 := mload(0xc0) |
| 9182 | // Selector of `log(uint256,bool,string,address)`. |
| 9183 | mstore(0x00, 0xef529018) |
| 9184 | mstore(0x20, p0) |
| 9185 | mstore(0x40, p1) |
| 9186 | mstore(0x60, 0x80) |
| 9187 | mstore(0x80, p3) |
| 9188 | writeString(0xa0, p2) |
| 9189 | } |
| 9190 | _sendLogPayload(0x1c, 0xc4); |
| 9191 | /// @solidity memory-safe-assembly |
| 9192 | assembly { |
| 9193 | mstore(0x00, m0) |
| 9194 | mstore(0x20, m1) |
| 9195 | mstore(0x40, m2) |
| 9196 | mstore(0x60, m3) |
| 9197 | mstore(0x80, m4) |
| 9198 | mstore(0xa0, m5) |
| 9199 | mstore(0xc0, m6) |
| 9200 | } |
| 9201 | } |
| 9202 | |
| 9203 | function log(uint256 p0, bool p1, bytes32 p2, bool p3) internal pure { |
| 9204 | bytes32 m0; |
| 9205 | bytes32 m1; |
| 9206 | bytes32 m2; |
| 9207 | bytes32 m3; |
| 9208 | bytes32 m4; |
| 9209 | bytes32 m5; |
| 9210 | bytes32 m6; |
| 9211 | /// @solidity memory-safe-assembly |
| 9212 | assembly { |
| 9213 | function writeString(pos, w) { |
| 9214 | let length := 0 |
| 9215 | for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } |
| 9216 | mstore(pos, length) |
| 9217 | let shift := sub(256, shl(3, length)) |
| 9218 | mstore(add(pos, 0x20), shl(shift, shr(shift, w))) |
| 9219 | } |
| 9220 | m0 := mload(0x00) |
| 9221 | m1 := mload(0x20) |
| 9222 | m2 := mload(0x40) |
| 9223 | m3 := mload(0x60) |
| 9224 | m4 := mload(0x80) |
| 9225 | m5 := mload(0xa0) |
| 9226 | m6 := mload(0xc0) |
| 9227 | // Selector of `log(uint256,bool,string,bool)`. |
| 9228 | mstore(0x00, 0xeb928d7f) |
| 9229 | mstore(0x20, p0) |
| 9230 | mstore(0x40, p1) |
| 9231 | mstore(0x60, 0x80) |
| 9232 | mstore(0x80, p3) |
| 9233 | writeString(0xa0, p2) |
| 9234 | } |
| 9235 | _sendLogPayload(0x1c, 0xc4); |
| 9236 | /// @solidity memory-safe-assembly |
| 9237 | assembly { |
| 9238 | mstore(0x00, m0) |
| 9239 | mstore(0x20, m1) |
| 9240 | mstore(0x40, m2) |
| 9241 | mstore(0x60, m3) |
| 9242 | mstore(0x80, m4) |
| 9243 | mstore(0xa0, m5) |
| 9244 | mstore(0xc0, m6) |
| 9245 | } |
| 9246 | } |
| 9247 | |
| 9248 | function log(uint256 p0, bool p1, bytes32 p2, uint256 p3) internal pure { |
| 9249 | bytes32 m0; |
| 9250 | bytes32 m1; |
| 9251 | bytes32 m2; |
| 9252 | bytes32 m3; |
| 9253 | bytes32 m4; |
| 9254 | bytes32 m5; |
| 9255 | bytes32 m6; |
| 9256 | /// @solidity memory-safe-assembly |
| 9257 | assembly { |
| 9258 | function writeString(pos, w) { |
| 9259 | let length := 0 |
| 9260 | for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } |
| 9261 | mstore(pos, length) |
| 9262 | let shift := sub(256, shl(3, length)) |
| 9263 | mstore(add(pos, 0x20), shl(shift, shr(shift, w))) |
| 9264 | } |
| 9265 | m0 := mload(0x00) |
| 9266 | m1 := mload(0x20) |
| 9267 | m2 := mload(0x40) |
| 9268 | m3 := mload(0x60) |
| 9269 | m4 := mload(0x80) |
| 9270 | m5 := mload(0xa0) |
| 9271 | m6 := mload(0xc0) |
| 9272 | // Selector of `log(uint256,bool,string,uint256)`. |
| 9273 | mstore(0x00, 0x2c1d0746) |
| 9274 | mstore(0x20, p0) |
| 9275 | mstore(0x40, p1) |
| 9276 | mstore(0x60, 0x80) |
| 9277 | mstore(0x80, p3) |
| 9278 | writeString(0xa0, p2) |
| 9279 | } |
| 9280 | _sendLogPayload(0x1c, 0xc4); |
| 9281 | /// @solidity memory-safe-assembly |
| 9282 | assembly { |
| 9283 | mstore(0x00, m0) |
| 9284 | mstore(0x20, m1) |
| 9285 | mstore(0x40, m2) |
| 9286 | mstore(0x60, m3) |
| 9287 | mstore(0x80, m4) |
| 9288 | mstore(0xa0, m5) |
| 9289 | mstore(0xc0, m6) |
| 9290 | } |
| 9291 | } |
| 9292 | |
| 9293 | function log(uint256 p0, bool p1, bytes32 p2, bytes32 p3) internal pure { |
| 9294 | bytes32 m0; |
| 9295 | bytes32 m1; |
| 9296 | bytes32 m2; |
| 9297 | bytes32 m3; |
| 9298 | bytes32 m4; |
| 9299 | bytes32 m5; |
| 9300 | bytes32 m6; |
| 9301 | bytes32 m7; |
| 9302 | bytes32 m8; |
| 9303 | /// @solidity memory-safe-assembly |
| 9304 | assembly { |
| 9305 | function writeString(pos, w) { |
| 9306 | let length := 0 |
| 9307 | for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } |
| 9308 | mstore(pos, length) |
| 9309 | let shift := sub(256, shl(3, length)) |
| 9310 | mstore(add(pos, 0x20), shl(shift, shr(shift, w))) |
| 9311 | } |
| 9312 | m0 := mload(0x00) |
| 9313 | m1 := mload(0x20) |
| 9314 | m2 := mload(0x40) |
| 9315 | m3 := mload(0x60) |
| 9316 | m4 := mload(0x80) |
| 9317 | m5 := mload(0xa0) |
| 9318 | m6 := mload(0xc0) |
| 9319 | m7 := mload(0xe0) |
| 9320 | m8 := mload(0x100) |
| 9321 | // Selector of `log(uint256,bool,string,string)`. |
| 9322 | mstore(0x00, 0x68c8b8bd) |
| 9323 | mstore(0x20, p0) |
| 9324 | mstore(0x40, p1) |
| 9325 | mstore(0x60, 0x80) |
| 9326 | mstore(0x80, 0xc0) |
| 9327 | writeString(0xa0, p2) |
| 9328 | writeString(0xe0, p3) |
| 9329 | } |
| 9330 | _sendLogPayload(0x1c, 0x104); |
| 9331 | /// @solidity memory-safe-assembly |
| 9332 | assembly { |
| 9333 | mstore(0x00, m0) |
| 9334 | mstore(0x20, m1) |
| 9335 | mstore(0x40, m2) |
| 9336 | mstore(0x60, m3) |
| 9337 | mstore(0x80, m4) |
| 9338 | mstore(0xa0, m5) |
| 9339 | mstore(0xc0, m6) |
| 9340 | mstore(0xe0, m7) |
| 9341 | mstore(0x100, m8) |
| 9342 | } |
| 9343 | } |
| 9344 | |
| 9345 | function log(uint256 p0, uint256 p1, address p2, address p3) internal pure { |
| 9346 | bytes32 m0; |
| 9347 | bytes32 m1; |
| 9348 | bytes32 m2; |
| 9349 | bytes32 m3; |
| 9350 | bytes32 m4; |
| 9351 | /// @solidity memory-safe-assembly |
| 9352 | assembly { |
| 9353 | m0 := mload(0x00) |
| 9354 | m1 := mload(0x20) |
| 9355 | m2 := mload(0x40) |
| 9356 | m3 := mload(0x60) |
| 9357 | m4 := mload(0x80) |
| 9358 | // Selector of `log(uint256,uint256,address,address)`. |
| 9359 | mstore(0x00, 0x56a5d1b1) |
| 9360 | mstore(0x20, p0) |
| 9361 | mstore(0x40, p1) |
| 9362 | mstore(0x60, p2) |
| 9363 | mstore(0x80, p3) |
| 9364 | } |
| 9365 | _sendLogPayload(0x1c, 0x84); |
| 9366 | /// @solidity memory-safe-assembly |
| 9367 | assembly { |
| 9368 | mstore(0x00, m0) |
| 9369 | mstore(0x20, m1) |
| 9370 | mstore(0x40, m2) |
| 9371 | mstore(0x60, m3) |
| 9372 | mstore(0x80, m4) |
| 9373 | } |
| 9374 | } |
| 9375 | |
| 9376 | function log(uint256 p0, uint256 p1, address p2, bool p3) internal pure { |
| 9377 | bytes32 m0; |
| 9378 | bytes32 m1; |
| 9379 | bytes32 m2; |
| 9380 | bytes32 m3; |
| 9381 | bytes32 m4; |
| 9382 | /// @solidity memory-safe-assembly |
| 9383 | assembly { |
| 9384 | m0 := mload(0x00) |
| 9385 | m1 := mload(0x20) |
| 9386 | m2 := mload(0x40) |
| 9387 | m3 := mload(0x60) |
| 9388 | m4 := mload(0x80) |
| 9389 | // Selector of `log(uint256,uint256,address,bool)`. |
| 9390 | mstore(0x00, 0x15cac476) |
| 9391 | mstore(0x20, p0) |
| 9392 | mstore(0x40, p1) |
| 9393 | mstore(0x60, p2) |
| 9394 | mstore(0x80, p3) |
| 9395 | } |
| 9396 | _sendLogPayload(0x1c, 0x84); |
| 9397 | /// @solidity memory-safe-assembly |
| 9398 | assembly { |
| 9399 | mstore(0x00, m0) |
| 9400 | mstore(0x20, m1) |
| 9401 | mstore(0x40, m2) |
| 9402 | mstore(0x60, m3) |
| 9403 | mstore(0x80, m4) |
| 9404 | } |
| 9405 | } |
| 9406 | |
| 9407 | function log(uint256 p0, uint256 p1, address p2, uint256 p3) internal pure { |
| 9408 | bytes32 m0; |
| 9409 | bytes32 m1; |
| 9410 | bytes32 m2; |
| 9411 | bytes32 m3; |
| 9412 | bytes32 m4; |
| 9413 | /// @solidity memory-safe-assembly |
| 9414 | assembly { |
| 9415 | m0 := mload(0x00) |
| 9416 | m1 := mload(0x20) |
| 9417 | m2 := mload(0x40) |
| 9418 | m3 := mload(0x60) |
| 9419 | m4 := mload(0x80) |
| 9420 | // Selector of `log(uint256,uint256,address,uint256)`. |
| 9421 | mstore(0x00, 0x88f6e4b2) |
| 9422 | mstore(0x20, p0) |
| 9423 | mstore(0x40, p1) |
| 9424 | mstore(0x60, p2) |
| 9425 | mstore(0x80, p3) |
| 9426 | } |
| 9427 | _sendLogPayload(0x1c, 0x84); |
| 9428 | /// @solidity memory-safe-assembly |
| 9429 | assembly { |
| 9430 | mstore(0x00, m0) |
| 9431 | mstore(0x20, m1) |
| 9432 | mstore(0x40, m2) |
| 9433 | mstore(0x60, m3) |
| 9434 | mstore(0x80, m4) |
| 9435 | } |
| 9436 | } |
| 9437 | |
| 9438 | function log(uint256 p0, uint256 p1, address p2, bytes32 p3) internal pure { |
| 9439 | bytes32 m0; |
| 9440 | bytes32 m1; |
| 9441 | bytes32 m2; |
| 9442 | bytes32 m3; |
| 9443 | bytes32 m4; |
| 9444 | bytes32 m5; |
| 9445 | bytes32 m6; |
| 9446 | /// @solidity memory-safe-assembly |
| 9447 | assembly { |
| 9448 | function writeString(pos, w) { |
| 9449 | let length := 0 |
| 9450 | for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } |
| 9451 | mstore(pos, length) |
| 9452 | let shift := sub(256, shl(3, length)) |
| 9453 | mstore(add(pos, 0x20), shl(shift, shr(shift, w))) |
| 9454 | } |
| 9455 | m0 := mload(0x00) |
| 9456 | m1 := mload(0x20) |
| 9457 | m2 := mload(0x40) |
| 9458 | m3 := mload(0x60) |
| 9459 | m4 := mload(0x80) |
| 9460 | m5 := mload(0xa0) |
| 9461 | m6 := mload(0xc0) |
| 9462 | // Selector of `log(uint256,uint256,address,string)`. |
| 9463 | mstore(0x00, 0x6cde40b8) |
| 9464 | mstore(0x20, p0) |
| 9465 | mstore(0x40, p1) |
| 9466 | mstore(0x60, p2) |
| 9467 | mstore(0x80, 0x80) |
| 9468 | writeString(0xa0, p3) |
| 9469 | } |
| 9470 | _sendLogPayload(0x1c, 0xc4); |
| 9471 | /// @solidity memory-safe-assembly |
| 9472 | assembly { |
| 9473 | mstore(0x00, m0) |
| 9474 | mstore(0x20, m1) |
| 9475 | mstore(0x40, m2) |
| 9476 | mstore(0x60, m3) |
| 9477 | mstore(0x80, m4) |
| 9478 | mstore(0xa0, m5) |
| 9479 | mstore(0xc0, m6) |
| 9480 | } |
| 9481 | } |
| 9482 | |
| 9483 | function log(uint256 p0, uint256 p1, bool p2, address p3) internal pure { |
| 9484 | bytes32 m0; |
| 9485 | bytes32 m1; |
| 9486 | bytes32 m2; |
| 9487 | bytes32 m3; |
| 9488 | bytes32 m4; |
| 9489 | /// @solidity memory-safe-assembly |
| 9490 | assembly { |
| 9491 | m0 := mload(0x00) |
| 9492 | m1 := mload(0x20) |
| 9493 | m2 := mload(0x40) |
| 9494 | m3 := mload(0x60) |
| 9495 | m4 := mload(0x80) |
| 9496 | // Selector of `log(uint256,uint256,bool,address)`. |
| 9497 | mstore(0x00, 0x9a816a83) |
| 9498 | mstore(0x20, p0) |
| 9499 | mstore(0x40, p1) |
| 9500 | mstore(0x60, p2) |
| 9501 | mstore(0x80, p3) |
| 9502 | } |
| 9503 | _sendLogPayload(0x1c, 0x84); |
| 9504 | /// @solidity memory-safe-assembly |
| 9505 | assembly { |
| 9506 | mstore(0x00, m0) |
| 9507 | mstore(0x20, m1) |
| 9508 | mstore(0x40, m2) |
| 9509 | mstore(0x60, m3) |
| 9510 | mstore(0x80, m4) |
| 9511 | } |
| 9512 | } |
| 9513 | |
| 9514 | function log(uint256 p0, uint256 p1, bool p2, bool p3) internal pure { |
| 9515 | bytes32 m0; |
| 9516 | bytes32 m1; |
| 9517 | bytes32 m2; |
| 9518 | bytes32 m3; |
| 9519 | bytes32 m4; |
| 9520 | /// @solidity memory-safe-assembly |
| 9521 | assembly { |
| 9522 | m0 := mload(0x00) |
| 9523 | m1 := mload(0x20) |
| 9524 | m2 := mload(0x40) |
| 9525 | m3 := mload(0x60) |
| 9526 | m4 := mload(0x80) |
| 9527 | // Selector of `log(uint256,uint256,bool,bool)`. |
| 9528 | mstore(0x00, 0xab085ae6) |
| 9529 | mstore(0x20, p0) |
| 9530 | mstore(0x40, p1) |
| 9531 | mstore(0x60, p2) |
| 9532 | mstore(0x80, p3) |
| 9533 | } |
| 9534 | _sendLogPayload(0x1c, 0x84); |
| 9535 | /// @solidity memory-safe-assembly |
| 9536 | assembly { |
| 9537 | mstore(0x00, m0) |
| 9538 | mstore(0x20, m1) |
| 9539 | mstore(0x40, m2) |
| 9540 | mstore(0x60, m3) |
| 9541 | mstore(0x80, m4) |
| 9542 | } |
| 9543 | } |
| 9544 | |
| 9545 | function log(uint256 p0, uint256 p1, bool p2, uint256 p3) internal pure { |
| 9546 | bytes32 m0; |
| 9547 | bytes32 m1; |
| 9548 | bytes32 m2; |
| 9549 | bytes32 m3; |
| 9550 | bytes32 m4; |
| 9551 | /// @solidity memory-safe-assembly |
| 9552 | assembly { |
| 9553 | m0 := mload(0x00) |
| 9554 | m1 := mload(0x20) |
| 9555 | m2 := mload(0x40) |
| 9556 | m3 := mload(0x60) |
| 9557 | m4 := mload(0x80) |
| 9558 | // Selector of `log(uint256,uint256,bool,uint256)`. |
| 9559 | mstore(0x00, 0xeb7f6fd2) |
| 9560 | mstore(0x20, p0) |
| 9561 | mstore(0x40, p1) |
| 9562 | mstore(0x60, p2) |
| 9563 | mstore(0x80, p3) |
| 9564 | } |
| 9565 | _sendLogPayload(0x1c, 0x84); |
| 9566 | /// @solidity memory-safe-assembly |
| 9567 | assembly { |
| 9568 | mstore(0x00, m0) |
| 9569 | mstore(0x20, m1) |
| 9570 | mstore(0x40, m2) |
| 9571 | mstore(0x60, m3) |
| 9572 | mstore(0x80, m4) |
| 9573 | } |
| 9574 | } |
| 9575 | |
| 9576 | function log(uint256 p0, uint256 p1, bool p2, bytes32 p3) internal pure { |
| 9577 | bytes32 m0; |
| 9578 | bytes32 m1; |
| 9579 | bytes32 m2; |
| 9580 | bytes32 m3; |
| 9581 | bytes32 m4; |
| 9582 | bytes32 m5; |
| 9583 | bytes32 m6; |
| 9584 | /// @solidity memory-safe-assembly |
| 9585 | assembly { |
| 9586 | function writeString(pos, w) { |
| 9587 | let length := 0 |
| 9588 | for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } |
| 9589 | mstore(pos, length) |
| 9590 | let shift := sub(256, shl(3, length)) |
| 9591 | mstore(add(pos, 0x20), shl(shift, shr(shift, w))) |
| 9592 | } |
| 9593 | m0 := mload(0x00) |
| 9594 | m1 := mload(0x20) |
| 9595 | m2 := mload(0x40) |
| 9596 | m3 := mload(0x60) |
| 9597 | m4 := mload(0x80) |
| 9598 | m5 := mload(0xa0) |
| 9599 | m6 := mload(0xc0) |
| 9600 | // Selector of `log(uint256,uint256,bool,string)`. |
| 9601 | mstore(0x00, 0xa5b4fc99) |
| 9602 | mstore(0x20, p0) |
| 9603 | mstore(0x40, p1) |
| 9604 | mstore(0x60, p2) |
| 9605 | mstore(0x80, 0x80) |
| 9606 | writeString(0xa0, p3) |
| 9607 | } |
| 9608 | _sendLogPayload(0x1c, 0xc4); |
| 9609 | /// @solidity memory-safe-assembly |
| 9610 | assembly { |
| 9611 | mstore(0x00, m0) |
| 9612 | mstore(0x20, m1) |
| 9613 | mstore(0x40, m2) |
| 9614 | mstore(0x60, m3) |
| 9615 | mstore(0x80, m4) |
| 9616 | mstore(0xa0, m5) |
| 9617 | mstore(0xc0, m6) |
| 9618 | } |
| 9619 | } |
| 9620 | |
| 9621 | function log(uint256 p0, uint256 p1, uint256 p2, address p3) internal pure { |
| 9622 | bytes32 m0; |
| 9623 | bytes32 m1; |
| 9624 | bytes32 m2; |
| 9625 | bytes32 m3; |
| 9626 | bytes32 m4; |
| 9627 | /// @solidity memory-safe-assembly |
| 9628 | assembly { |
| 9629 | m0 := mload(0x00) |
| 9630 | m1 := mload(0x20) |
| 9631 | m2 := mload(0x40) |
| 9632 | m3 := mload(0x60) |
| 9633 | m4 := mload(0x80) |
| 9634 | // Selector of `log(uint256,uint256,uint256,address)`. |
| 9635 | mstore(0x00, 0xfa8185af) |
| 9636 | mstore(0x20, p0) |
| 9637 | mstore(0x40, p1) |
| 9638 | mstore(0x60, p2) |
| 9639 | mstore(0x80, p3) |
| 9640 | } |
| 9641 | _sendLogPayload(0x1c, 0x84); |
| 9642 | /// @solidity memory-safe-assembly |
| 9643 | assembly { |
| 9644 | mstore(0x00, m0) |
| 9645 | mstore(0x20, m1) |
| 9646 | mstore(0x40, m2) |
| 9647 | mstore(0x60, m3) |
| 9648 | mstore(0x80, m4) |
| 9649 | } |
| 9650 | } |
| 9651 | |
| 9652 | function log(uint256 p0, uint256 p1, uint256 p2, bool p3) internal pure { |
| 9653 | bytes32 m0; |
| 9654 | bytes32 m1; |
| 9655 | bytes32 m2; |
| 9656 | bytes32 m3; |
| 9657 | bytes32 m4; |
| 9658 | /// @solidity memory-safe-assembly |
| 9659 | assembly { |
| 9660 | m0 := mload(0x00) |
| 9661 | m1 := mload(0x20) |
| 9662 | m2 := mload(0x40) |
| 9663 | m3 := mload(0x60) |
| 9664 | m4 := mload(0x80) |
| 9665 | // Selector of `log(uint256,uint256,uint256,bool)`. |
| 9666 | mstore(0x00, 0xc598d185) |
| 9667 | mstore(0x20, p0) |
| 9668 | mstore(0x40, p1) |
| 9669 | mstore(0x60, p2) |
| 9670 | mstore(0x80, p3) |
| 9671 | } |
| 9672 | _sendLogPayload(0x1c, 0x84); |
| 9673 | /// @solidity memory-safe-assembly |
| 9674 | assembly { |
| 9675 | mstore(0x00, m0) |
| 9676 | mstore(0x20, m1) |
| 9677 | mstore(0x40, m2) |
| 9678 | mstore(0x60, m3) |
| 9679 | mstore(0x80, m4) |
| 9680 | } |
| 9681 | } |
| 9682 | |
| 9683 | function log(uint256 p0, uint256 p1, uint256 p2, uint256 p3) internal pure { |
| 9684 | bytes32 m0; |
| 9685 | bytes32 m1; |
| 9686 | bytes32 m2; |
| 9687 | bytes32 m3; |
| 9688 | bytes32 m4; |
| 9689 | /// @solidity memory-safe-assembly |
| 9690 | assembly { |
| 9691 | m0 := mload(0x00) |
| 9692 | m1 := mload(0x20) |
| 9693 | m2 := mload(0x40) |
| 9694 | m3 := mload(0x60) |
| 9695 | m4 := mload(0x80) |
| 9696 | // Selector of `log(uint256,uint256,uint256,uint256)`. |
| 9697 | mstore(0x00, 0x193fb800) |
| 9698 | mstore(0x20, p0) |
| 9699 | mstore(0x40, p1) |
| 9700 | mstore(0x60, p2) |
| 9701 | mstore(0x80, p3) |
| 9702 | } |
| 9703 | _sendLogPayload(0x1c, 0x84); |
| 9704 | /// @solidity memory-safe-assembly |
| 9705 | assembly { |
| 9706 | mstore(0x00, m0) |
| 9707 | mstore(0x20, m1) |
| 9708 | mstore(0x40, m2) |
| 9709 | mstore(0x60, m3) |
| 9710 | mstore(0x80, m4) |
| 9711 | } |
| 9712 | } |
| 9713 | |
| 9714 | function log(uint256 p0, uint256 p1, uint256 p2, bytes32 p3) internal pure { |
| 9715 | bytes32 m0; |
| 9716 | bytes32 m1; |
| 9717 | bytes32 m2; |
| 9718 | bytes32 m3; |
| 9719 | bytes32 m4; |
| 9720 | bytes32 m5; |
| 9721 | bytes32 m6; |
| 9722 | /// @solidity memory-safe-assembly |
| 9723 | assembly { |
| 9724 | function writeString(pos, w) { |
| 9725 | let length := 0 |
| 9726 | for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } |
| 9727 | mstore(pos, length) |
| 9728 | let shift := sub(256, shl(3, length)) |
| 9729 | mstore(add(pos, 0x20), shl(shift, shr(shift, w))) |
| 9730 | } |
| 9731 | m0 := mload(0x00) |
| 9732 | m1 := mload(0x20) |
| 9733 | m2 := mload(0x40) |
| 9734 | m3 := mload(0x60) |
| 9735 | m4 := mload(0x80) |
| 9736 | m5 := mload(0xa0) |
| 9737 | m6 := mload(0xc0) |
| 9738 | // Selector of `log(uint256,uint256,uint256,string)`. |
| 9739 | mstore(0x00, 0x59cfcbe3) |
| 9740 | mstore(0x20, p0) |
| 9741 | mstore(0x40, p1) |
| 9742 | mstore(0x60, p2) |
| 9743 | mstore(0x80, 0x80) |
| 9744 | writeString(0xa0, p3) |
| 9745 | } |
| 9746 | _sendLogPayload(0x1c, 0xc4); |
| 9747 | /// @solidity memory-safe-assembly |
| 9748 | assembly { |
| 9749 | mstore(0x00, m0) |
| 9750 | mstore(0x20, m1) |
| 9751 | mstore(0x40, m2) |
| 9752 | mstore(0x60, m3) |
| 9753 | mstore(0x80, m4) |
| 9754 | mstore(0xa0, m5) |
| 9755 | mstore(0xc0, m6) |
| 9756 | } |
| 9757 | } |
| 9758 | |
| 9759 | function log(uint256 p0, uint256 p1, bytes32 p2, address p3) internal pure { |
| 9760 | bytes32 m0; |
| 9761 | bytes32 m1; |
| 9762 | bytes32 m2; |
| 9763 | bytes32 m3; |
| 9764 | bytes32 m4; |
| 9765 | bytes32 m5; |
| 9766 | bytes32 m6; |
| 9767 | /// @solidity memory-safe-assembly |
| 9768 | assembly { |
| 9769 | function writeString(pos, w) { |
| 9770 | let length := 0 |
| 9771 | for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } |
| 9772 | mstore(pos, length) |
| 9773 | let shift := sub(256, shl(3, length)) |
| 9774 | mstore(add(pos, 0x20), shl(shift, shr(shift, w))) |
| 9775 | } |
| 9776 | m0 := mload(0x00) |
| 9777 | m1 := mload(0x20) |
| 9778 | m2 := mload(0x40) |
| 9779 | m3 := mload(0x60) |
| 9780 | m4 := mload(0x80) |
| 9781 | m5 := mload(0xa0) |
| 9782 | m6 := mload(0xc0) |
| 9783 | // Selector of `log(uint256,uint256,string,address)`. |
| 9784 | mstore(0x00, 0x42d21db7) |
| 9785 | mstore(0x20, p0) |
| 9786 | mstore(0x40, p1) |
| 9787 | mstore(0x60, 0x80) |
| 9788 | mstore(0x80, p3) |
| 9789 | writeString(0xa0, p2) |
| 9790 | } |
| 9791 | _sendLogPayload(0x1c, 0xc4); |
| 9792 | /// @solidity memory-safe-assembly |
| 9793 | assembly { |
| 9794 | mstore(0x00, m0) |
| 9795 | mstore(0x20, m1) |
| 9796 | mstore(0x40, m2) |
| 9797 | mstore(0x60, m3) |
| 9798 | mstore(0x80, m4) |
| 9799 | mstore(0xa0, m5) |
| 9800 | mstore(0xc0, m6) |
| 9801 | } |
| 9802 | } |
| 9803 | |
| 9804 | function log(uint256 p0, uint256 p1, bytes32 p2, bool p3) internal pure { |
| 9805 | bytes32 m0; |
| 9806 | bytes32 m1; |
| 9807 | bytes32 m2; |
| 9808 | bytes32 m3; |
| 9809 | bytes32 m4; |
| 9810 | bytes32 m5; |
| 9811 | bytes32 m6; |
| 9812 | /// @solidity memory-safe-assembly |
| 9813 | assembly { |
| 9814 | function writeString(pos, w) { |
| 9815 | let length := 0 |
| 9816 | for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } |
| 9817 | mstore(pos, length) |
| 9818 | let shift := sub(256, shl(3, length)) |
| 9819 | mstore(add(pos, 0x20), shl(shift, shr(shift, w))) |
| 9820 | } |
| 9821 | m0 := mload(0x00) |
| 9822 | m1 := mload(0x20) |
| 9823 | m2 := mload(0x40) |
| 9824 | m3 := mload(0x60) |
| 9825 | m4 := mload(0x80) |
| 9826 | m5 := mload(0xa0) |
| 9827 | m6 := mload(0xc0) |
| 9828 | // Selector of `log(uint256,uint256,string,bool)`. |
| 9829 | mstore(0x00, 0x7af6ab25) |
| 9830 | mstore(0x20, p0) |
| 9831 | mstore(0x40, p1) |
| 9832 | mstore(0x60, 0x80) |
| 9833 | mstore(0x80, p3) |
| 9834 | writeString(0xa0, p2) |
| 9835 | } |
| 9836 | _sendLogPayload(0x1c, 0xc4); |
| 9837 | /// @solidity memory-safe-assembly |
| 9838 | assembly { |
| 9839 | mstore(0x00, m0) |
| 9840 | mstore(0x20, m1) |
| 9841 | mstore(0x40, m2) |
| 9842 | mstore(0x60, m3) |
| 9843 | mstore(0x80, m4) |
| 9844 | mstore(0xa0, m5) |
| 9845 | mstore(0xc0, m6) |
| 9846 | } |
| 9847 | } |
| 9848 | |
| 9849 | function log(uint256 p0, uint256 p1, bytes32 p2, uint256 p3) internal pure { |
| 9850 | bytes32 m0; |
| 9851 | bytes32 m1; |
| 9852 | bytes32 m2; |
| 9853 | bytes32 m3; |
| 9854 | bytes32 m4; |
| 9855 | bytes32 m5; |
| 9856 | bytes32 m6; |
| 9857 | /// @solidity memory-safe-assembly |
| 9858 | assembly { |
| 9859 | function writeString(pos, w) { |
| 9860 | let length := 0 |
| 9861 | for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } |
| 9862 | mstore(pos, length) |
| 9863 | let shift := sub(256, shl(3, length)) |
| 9864 | mstore(add(pos, 0x20), shl(shift, shr(shift, w))) |
| 9865 | } |
| 9866 | m0 := mload(0x00) |
| 9867 | m1 := mload(0x20) |
| 9868 | m2 := mload(0x40) |
| 9869 | m3 := mload(0x60) |
| 9870 | m4 := mload(0x80) |
| 9871 | m5 := mload(0xa0) |
| 9872 | m6 := mload(0xc0) |
| 9873 | // Selector of `log(uint256,uint256,string,uint256)`. |
| 9874 | mstore(0x00, 0x5da297eb) |
| 9875 | mstore(0x20, p0) |
| 9876 | mstore(0x40, p1) |
| 9877 | mstore(0x60, 0x80) |
| 9878 | mstore(0x80, p3) |
| 9879 | writeString(0xa0, p2) |
| 9880 | } |
| 9881 | _sendLogPayload(0x1c, 0xc4); |
| 9882 | /// @solidity memory-safe-assembly |
| 9883 | assembly { |
| 9884 | mstore(0x00, m0) |
| 9885 | mstore(0x20, m1) |
| 9886 | mstore(0x40, m2) |
| 9887 | mstore(0x60, m3) |
| 9888 | mstore(0x80, m4) |
| 9889 | mstore(0xa0, m5) |
| 9890 | mstore(0xc0, m6) |
| 9891 | } |
| 9892 | } |
| 9893 | |
| 9894 | function log(uint256 p0, uint256 p1, bytes32 p2, bytes32 p3) internal pure { |
| 9895 | bytes32 m0; |
| 9896 | bytes32 m1; |
| 9897 | bytes32 m2; |
| 9898 | bytes32 m3; |
| 9899 | bytes32 m4; |
| 9900 | bytes32 m5; |
| 9901 | bytes32 m6; |
| 9902 | bytes32 m7; |
| 9903 | bytes32 m8; |
| 9904 | /// @solidity memory-safe-assembly |
| 9905 | assembly { |
| 9906 | function writeString(pos, w) { |
| 9907 | let length := 0 |
| 9908 | for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } |
| 9909 | mstore(pos, length) |
| 9910 | let shift := sub(256, shl(3, length)) |
| 9911 | mstore(add(pos, 0x20), shl(shift, shr(shift, w))) |
| 9912 | } |
| 9913 | m0 := mload(0x00) |
| 9914 | m1 := mload(0x20) |
| 9915 | m2 := mload(0x40) |
| 9916 | m3 := mload(0x60) |
| 9917 | m4 := mload(0x80) |
| 9918 | m5 := mload(0xa0) |
| 9919 | m6 := mload(0xc0) |
| 9920 | m7 := mload(0xe0) |
| 9921 | m8 := mload(0x100) |
| 9922 | // Selector of `log(uint256,uint256,string,string)`. |
| 9923 | mstore(0x00, 0x27d8afd2) |
| 9924 | mstore(0x20, p0) |
| 9925 | mstore(0x40, p1) |
| 9926 | mstore(0x60, 0x80) |
| 9927 | mstore(0x80, 0xc0) |
| 9928 | writeString(0xa0, p2) |
| 9929 | writeString(0xe0, p3) |
| 9930 | } |
| 9931 | _sendLogPayload(0x1c, 0x104); |
| 9932 | /// @solidity memory-safe-assembly |
| 9933 | assembly { |
| 9934 | mstore(0x00, m0) |
| 9935 | mstore(0x20, m1) |
| 9936 | mstore(0x40, m2) |
| 9937 | mstore(0x60, m3) |
| 9938 | mstore(0x80, m4) |
| 9939 | mstore(0xa0, m5) |
| 9940 | mstore(0xc0, m6) |
| 9941 | mstore(0xe0, m7) |
| 9942 | mstore(0x100, m8) |
| 9943 | } |
| 9944 | } |
| 9945 | |
| 9946 | function log(uint256 p0, bytes32 p1, address p2, address p3) internal pure { |
| 9947 | bytes32 m0; |
| 9948 | bytes32 m1; |
| 9949 | bytes32 m2; |
| 9950 | bytes32 m3; |
| 9951 | bytes32 m4; |
| 9952 | bytes32 m5; |
| 9953 | bytes32 m6; |
| 9954 | /// @solidity memory-safe-assembly |
| 9955 | assembly { |
| 9956 | function writeString(pos, w) { |
| 9957 | let length := 0 |
| 9958 | for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } |
| 9959 | mstore(pos, length) |
| 9960 | let shift := sub(256, shl(3, length)) |
| 9961 | mstore(add(pos, 0x20), shl(shift, shr(shift, w))) |
| 9962 | } |
| 9963 | m0 := mload(0x00) |
| 9964 | m1 := mload(0x20) |
| 9965 | m2 := mload(0x40) |
| 9966 | m3 := mload(0x60) |
| 9967 | m4 := mload(0x80) |
| 9968 | m5 := mload(0xa0) |
| 9969 | m6 := mload(0xc0) |
| 9970 | // Selector of `log(uint256,string,address,address)`. |
| 9971 | mstore(0x00, 0x6168ed61) |
| 9972 | mstore(0x20, p0) |
| 9973 | mstore(0x40, 0x80) |
| 9974 | mstore(0x60, p2) |
| 9975 | mstore(0x80, p3) |
| 9976 | writeString(0xa0, p1) |
| 9977 | } |
| 9978 | _sendLogPayload(0x1c, 0xc4); |
| 9979 | /// @solidity memory-safe-assembly |
| 9980 | assembly { |
| 9981 | mstore(0x00, m0) |
| 9982 | mstore(0x20, m1) |
| 9983 | mstore(0x40, m2) |
| 9984 | mstore(0x60, m3) |
| 9985 | mstore(0x80, m4) |
| 9986 | mstore(0xa0, m5) |
| 9987 | mstore(0xc0, m6) |
| 9988 | } |
| 9989 | } |
| 9990 | |
| 9991 | function log(uint256 p0, bytes32 p1, address p2, bool p3) internal pure { |
| 9992 | bytes32 m0; |
| 9993 | bytes32 m1; |
| 9994 | bytes32 m2; |
| 9995 | bytes32 m3; |
| 9996 | bytes32 m4; |
| 9997 | bytes32 m5; |
| 9998 | bytes32 m6; |
| 9999 | /// @solidity memory-safe-assembly |
| 10000 | assembly { |
| 10001 | function writeString(pos, w) { |
| 10002 | let length := 0 |
| 10003 | for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } |
| 10004 | mstore(pos, length) |
| 10005 | let shift := sub(256, shl(3, length)) |
| 10006 | mstore(add(pos, 0x20), shl(shift, shr(shift, w))) |
| 10007 | } |
| 10008 | m0 := mload(0x00) |
| 10009 | m1 := mload(0x20) |
| 10010 | m2 := mload(0x40) |
| 10011 | m3 := mload(0x60) |
| 10012 | m4 := mload(0x80) |
| 10013 | m5 := mload(0xa0) |
| 10014 | m6 := mload(0xc0) |
| 10015 | // Selector of `log(uint256,string,address,bool)`. |
| 10016 | mstore(0x00, 0x90c30a56) |
| 10017 | mstore(0x20, p0) |
| 10018 | mstore(0x40, 0x80) |
| 10019 | mstore(0x60, p2) |
| 10020 | mstore(0x80, p3) |
| 10021 | writeString(0xa0, p1) |
| 10022 | } |
| 10023 | _sendLogPayload(0x1c, 0xc4); |
| 10024 | /// @solidity memory-safe-assembly |
| 10025 | assembly { |
| 10026 | mstore(0x00, m0) |
| 10027 | mstore(0x20, m1) |
| 10028 | mstore(0x40, m2) |
| 10029 | mstore(0x60, m3) |
| 10030 | mstore(0x80, m4) |
| 10031 | mstore(0xa0, m5) |
| 10032 | mstore(0xc0, m6) |
| 10033 | } |
| 10034 | } |
| 10035 | |
| 10036 | function log(uint256 p0, bytes32 p1, address p2, uint256 p3) internal pure { |
| 10037 | bytes32 m0; |
| 10038 | bytes32 m1; |
| 10039 | bytes32 m2; |
| 10040 | bytes32 m3; |
| 10041 | bytes32 m4; |
| 10042 | bytes32 m5; |
| 10043 | bytes32 m6; |
| 10044 | /// @solidity memory-safe-assembly |
| 10045 | assembly { |
| 10046 | function writeString(pos, w) { |
| 10047 | let length := 0 |
| 10048 | for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } |
| 10049 | mstore(pos, length) |
| 10050 | let shift := sub(256, shl(3, length)) |
| 10051 | mstore(add(pos, 0x20), shl(shift, shr(shift, w))) |
| 10052 | } |
| 10053 | m0 := mload(0x00) |
| 10054 | m1 := mload(0x20) |
| 10055 | m2 := mload(0x40) |
| 10056 | m3 := mload(0x60) |
| 10057 | m4 := mload(0x80) |
| 10058 | m5 := mload(0xa0) |
| 10059 | m6 := mload(0xc0) |
| 10060 | // Selector of `log(uint256,string,address,uint256)`. |
| 10061 | mstore(0x00, 0xe8d3018d) |
| 10062 | mstore(0x20, p0) |
| 10063 | mstore(0x40, 0x80) |
| 10064 | mstore(0x60, p2) |
| 10065 | mstore(0x80, p3) |
| 10066 | writeString(0xa0, p1) |
| 10067 | } |
| 10068 | _sendLogPayload(0x1c, 0xc4); |
| 10069 | /// @solidity memory-safe-assembly |
| 10070 | assembly { |
| 10071 | mstore(0x00, m0) |
| 10072 | mstore(0x20, m1) |
| 10073 | mstore(0x40, m2) |
| 10074 | mstore(0x60, m3) |
| 10075 | mstore(0x80, m4) |
| 10076 | mstore(0xa0, m5) |
| 10077 | mstore(0xc0, m6) |
| 10078 | } |
| 10079 | } |
| 10080 | |
| 10081 | function log(uint256 p0, bytes32 p1, address p2, bytes32 p3) internal pure { |
| 10082 | bytes32 m0; |
| 10083 | bytes32 m1; |
| 10084 | bytes32 m2; |
| 10085 | bytes32 m3; |
| 10086 | bytes32 m4; |
| 10087 | bytes32 m5; |
| 10088 | bytes32 m6; |
| 10089 | bytes32 m7; |
| 10090 | bytes32 m8; |
| 10091 | /// @solidity memory-safe-assembly |
| 10092 | assembly { |
| 10093 | function writeString(pos, w) { |
| 10094 | let length := 0 |
| 10095 | for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } |
| 10096 | mstore(pos, length) |
| 10097 | let shift := sub(256, shl(3, length)) |
| 10098 | mstore(add(pos, 0x20), shl(shift, shr(shift, w))) |
| 10099 | } |
| 10100 | m0 := mload(0x00) |
| 10101 | m1 := mload(0x20) |
| 10102 | m2 := mload(0x40) |
| 10103 | m3 := mload(0x60) |
| 10104 | m4 := mload(0x80) |
| 10105 | m5 := mload(0xa0) |
| 10106 | m6 := mload(0xc0) |
| 10107 | m7 := mload(0xe0) |
| 10108 | m8 := mload(0x100) |
| 10109 | // Selector of `log(uint256,string,address,string)`. |
| 10110 | mstore(0x00, 0x9c3adfa1) |
| 10111 | mstore(0x20, p0) |
| 10112 | mstore(0x40, 0x80) |
| 10113 | mstore(0x60, p2) |
| 10114 | mstore(0x80, 0xc0) |
| 10115 | writeString(0xa0, p1) |
| 10116 | writeString(0xe0, p3) |
| 10117 | } |
| 10118 | _sendLogPayload(0x1c, 0x104); |
| 10119 | /// @solidity memory-safe-assembly |
| 10120 | assembly { |
| 10121 | mstore(0x00, m0) |
| 10122 | mstore(0x20, m1) |
| 10123 | mstore(0x40, m2) |
| 10124 | mstore(0x60, m3) |
| 10125 | mstore(0x80, m4) |
| 10126 | mstore(0xa0, m5) |
| 10127 | mstore(0xc0, m6) |
| 10128 | mstore(0xe0, m7) |
| 10129 | mstore(0x100, m8) |
| 10130 | } |
| 10131 | } |
| 10132 | |
| 10133 | function log(uint256 p0, bytes32 p1, bool p2, address p3) internal pure { |
| 10134 | bytes32 m0; |
| 10135 | bytes32 m1; |
| 10136 | bytes32 m2; |
| 10137 | bytes32 m3; |
| 10138 | bytes32 m4; |
| 10139 | bytes32 m5; |
| 10140 | bytes32 m6; |
| 10141 | /// @solidity memory-safe-assembly |
| 10142 | assembly { |
| 10143 | function writeString(pos, w) { |
| 10144 | let length := 0 |
| 10145 | for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } |
| 10146 | mstore(pos, length) |
| 10147 | let shift := sub(256, shl(3, length)) |
| 10148 | mstore(add(pos, 0x20), shl(shift, shr(shift, w))) |
| 10149 | } |
| 10150 | m0 := mload(0x00) |
| 10151 | m1 := mload(0x20) |
| 10152 | m2 := mload(0x40) |
| 10153 | m3 := mload(0x60) |
| 10154 | m4 := mload(0x80) |
| 10155 | m5 := mload(0xa0) |
| 10156 | m6 := mload(0xc0) |
| 10157 | // Selector of `log(uint256,string,bool,address)`. |
| 10158 | mstore(0x00, 0xae2ec581) |
| 10159 | mstore(0x20, p0) |
| 10160 | mstore(0x40, 0x80) |
| 10161 | mstore(0x60, p2) |
| 10162 | mstore(0x80, p3) |
| 10163 | writeString(0xa0, p1) |
| 10164 | } |
| 10165 | _sendLogPayload(0x1c, 0xc4); |
| 10166 | /// @solidity memory-safe-assembly |
| 10167 | assembly { |
| 10168 | mstore(0x00, m0) |
| 10169 | mstore(0x20, m1) |
| 10170 | mstore(0x40, m2) |
| 10171 | mstore(0x60, m3) |
| 10172 | mstore(0x80, m4) |
| 10173 | mstore(0xa0, m5) |
| 10174 | mstore(0xc0, m6) |
| 10175 | } |
| 10176 | } |
| 10177 | |
| 10178 | function log(uint256 p0, bytes32 p1, bool p2, bool p3) internal pure { |
| 10179 | bytes32 m0; |
| 10180 | bytes32 m1; |
| 10181 | bytes32 m2; |
| 10182 | bytes32 m3; |
| 10183 | bytes32 m4; |
| 10184 | bytes32 m5; |
| 10185 | bytes32 m6; |
| 10186 | /// @solidity memory-safe-assembly |
| 10187 | assembly { |
| 10188 | function writeString(pos, w) { |
| 10189 | let length := 0 |
| 10190 | for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } |
| 10191 | mstore(pos, length) |
| 10192 | let shift := sub(256, shl(3, length)) |
| 10193 | mstore(add(pos, 0x20), shl(shift, shr(shift, w))) |
| 10194 | } |
| 10195 | m0 := mload(0x00) |
| 10196 | m1 := mload(0x20) |
| 10197 | m2 := mload(0x40) |
| 10198 | m3 := mload(0x60) |
| 10199 | m4 := mload(0x80) |
| 10200 | m5 := mload(0xa0) |
| 10201 | m6 := mload(0xc0) |
| 10202 | // Selector of `log(uint256,string,bool,bool)`. |
| 10203 | mstore(0x00, 0xba535d9c) |
| 10204 | mstore(0x20, p0) |
| 10205 | mstore(0x40, 0x80) |
| 10206 | mstore(0x60, p2) |
| 10207 | mstore(0x80, p3) |
| 10208 | writeString(0xa0, p1) |
| 10209 | } |
| 10210 | _sendLogPayload(0x1c, 0xc4); |
| 10211 | /// @solidity memory-safe-assembly |
| 10212 | assembly { |
| 10213 | mstore(0x00, m0) |
| 10214 | mstore(0x20, m1) |
| 10215 | mstore(0x40, m2) |
| 10216 | mstore(0x60, m3) |
| 10217 | mstore(0x80, m4) |
| 10218 | mstore(0xa0, m5) |
| 10219 | mstore(0xc0, m6) |
| 10220 | } |
| 10221 | } |
| 10222 | |
| 10223 | function log(uint256 p0, bytes32 p1, bool p2, uint256 p3) internal pure { |
| 10224 | bytes32 m0; |
| 10225 | bytes32 m1; |
| 10226 | bytes32 m2; |
| 10227 | bytes32 m3; |
| 10228 | bytes32 m4; |
| 10229 | bytes32 m5; |
| 10230 | bytes32 m6; |
| 10231 | /// @solidity memory-safe-assembly |
| 10232 | assembly { |
| 10233 | function writeString(pos, w) { |
| 10234 | let length := 0 |
| 10235 | for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } |
| 10236 | mstore(pos, length) |
| 10237 | let shift := sub(256, shl(3, length)) |
| 10238 | mstore(add(pos, 0x20), shl(shift, shr(shift, w))) |
| 10239 | } |
| 10240 | m0 := mload(0x00) |
| 10241 | m1 := mload(0x20) |
| 10242 | m2 := mload(0x40) |
| 10243 | m3 := mload(0x60) |
| 10244 | m4 := mload(0x80) |
| 10245 | m5 := mload(0xa0) |
| 10246 | m6 := mload(0xc0) |
| 10247 | // Selector of `log(uint256,string,bool,uint256)`. |
| 10248 | mstore(0x00, 0xcf009880) |
| 10249 | mstore(0x20, p0) |
| 10250 | mstore(0x40, 0x80) |
| 10251 | mstore(0x60, p2) |
| 10252 | mstore(0x80, p3) |
| 10253 | writeString(0xa0, p1) |
| 10254 | } |
| 10255 | _sendLogPayload(0x1c, 0xc4); |
| 10256 | /// @solidity memory-safe-assembly |
| 10257 | assembly { |
| 10258 | mstore(0x00, m0) |
| 10259 | mstore(0x20, m1) |
| 10260 | mstore(0x40, m2) |
| 10261 | mstore(0x60, m3) |
| 10262 | mstore(0x80, m4) |
| 10263 | mstore(0xa0, m5) |
| 10264 | mstore(0xc0, m6) |
| 10265 | } |
| 10266 | } |
| 10267 | |
| 10268 | function log(uint256 p0, bytes32 p1, bool p2, bytes32 p3) internal pure { |
| 10269 | bytes32 m0; |
| 10270 | bytes32 m1; |
| 10271 | bytes32 m2; |
| 10272 | bytes32 m3; |
| 10273 | bytes32 m4; |
| 10274 | bytes32 m5; |
| 10275 | bytes32 m6; |
| 10276 | bytes32 m7; |
| 10277 | bytes32 m8; |
| 10278 | /// @solidity memory-safe-assembly |
| 10279 | assembly { |
| 10280 | function writeString(pos, w) { |
| 10281 | let length := 0 |
| 10282 | for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } |
| 10283 | mstore(pos, length) |
| 10284 | let shift := sub(256, shl(3, length)) |
| 10285 | mstore(add(pos, 0x20), shl(shift, shr(shift, w))) |
| 10286 | } |
| 10287 | m0 := mload(0x00) |
| 10288 | m1 := mload(0x20) |
| 10289 | m2 := mload(0x40) |
| 10290 | m3 := mload(0x60) |
| 10291 | m4 := mload(0x80) |
| 10292 | m5 := mload(0xa0) |
| 10293 | m6 := mload(0xc0) |
| 10294 | m7 := mload(0xe0) |
| 10295 | m8 := mload(0x100) |
| 10296 | // Selector of `log(uint256,string,bool,string)`. |
| 10297 | mstore(0x00, 0xd2d423cd) |
| 10298 | mstore(0x20, p0) |
| 10299 | mstore(0x40, 0x80) |
| 10300 | mstore(0x60, p2) |
| 10301 | mstore(0x80, 0xc0) |
| 10302 | writeString(0xa0, p1) |
| 10303 | writeString(0xe0, p3) |
| 10304 | } |
| 10305 | _sendLogPayload(0x1c, 0x104); |
| 10306 | /// @solidity memory-safe-assembly |
| 10307 | assembly { |
| 10308 | mstore(0x00, m0) |
| 10309 | mstore(0x20, m1) |
| 10310 | mstore(0x40, m2) |
| 10311 | mstore(0x60, m3) |
| 10312 | mstore(0x80, m4) |
| 10313 | mstore(0xa0, m5) |
| 10314 | mstore(0xc0, m6) |
| 10315 | mstore(0xe0, m7) |
| 10316 | mstore(0x100, m8) |
| 10317 | } |
| 10318 | } |
| 10319 | |
| 10320 | function log(uint256 p0, bytes32 p1, uint256 p2, address p3) internal pure { |
| 10321 | bytes32 m0; |
| 10322 | bytes32 m1; |
| 10323 | bytes32 m2; |
| 10324 | bytes32 m3; |
| 10325 | bytes32 m4; |
| 10326 | bytes32 m5; |
| 10327 | bytes32 m6; |
| 10328 | /// @solidity memory-safe-assembly |
| 10329 | assembly { |
| 10330 | function writeString(pos, w) { |
| 10331 | let length := 0 |
| 10332 | for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } |
| 10333 | mstore(pos, length) |
| 10334 | let shift := sub(256, shl(3, length)) |
| 10335 | mstore(add(pos, 0x20), shl(shift, shr(shift, w))) |
| 10336 | } |
| 10337 | m0 := mload(0x00) |
| 10338 | m1 := mload(0x20) |
| 10339 | m2 := mload(0x40) |
| 10340 | m3 := mload(0x60) |
| 10341 | m4 := mload(0x80) |
| 10342 | m5 := mload(0xa0) |
| 10343 | m6 := mload(0xc0) |
| 10344 | // Selector of `log(uint256,string,uint256,address)`. |
| 10345 | mstore(0x00, 0x3b2279b4) |
| 10346 | mstore(0x20, p0) |
| 10347 | mstore(0x40, 0x80) |
| 10348 | mstore(0x60, p2) |
| 10349 | mstore(0x80, p3) |
| 10350 | writeString(0xa0, p1) |
| 10351 | } |
| 10352 | _sendLogPayload(0x1c, 0xc4); |
| 10353 | /// @solidity memory-safe-assembly |
| 10354 | assembly { |
| 10355 | mstore(0x00, m0) |
| 10356 | mstore(0x20, m1) |
| 10357 | mstore(0x40, m2) |
| 10358 | mstore(0x60, m3) |
| 10359 | mstore(0x80, m4) |
| 10360 | mstore(0xa0, m5) |
| 10361 | mstore(0xc0, m6) |
| 10362 | } |
| 10363 | } |
| 10364 | |
| 10365 | function log(uint256 p0, bytes32 p1, uint256 p2, bool p3) internal pure { |
| 10366 | bytes32 m0; |
| 10367 | bytes32 m1; |
| 10368 | bytes32 m2; |
| 10369 | bytes32 m3; |
| 10370 | bytes32 m4; |
| 10371 | bytes32 m5; |
| 10372 | bytes32 m6; |
| 10373 | /// @solidity memory-safe-assembly |
| 10374 | assembly { |
| 10375 | function writeString(pos, w) { |
| 10376 | let length := 0 |
| 10377 | for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } |
| 10378 | mstore(pos, length) |
| 10379 | let shift := sub(256, shl(3, length)) |
| 10380 | mstore(add(pos, 0x20), shl(shift, shr(shift, w))) |
| 10381 | } |
| 10382 | m0 := mload(0x00) |
| 10383 | m1 := mload(0x20) |
| 10384 | m2 := mload(0x40) |
| 10385 | m3 := mload(0x60) |
| 10386 | m4 := mload(0x80) |
| 10387 | m5 := mload(0xa0) |
| 10388 | m6 := mload(0xc0) |
| 10389 | // Selector of `log(uint256,string,uint256,bool)`. |
| 10390 | mstore(0x00, 0x691a8f74) |
| 10391 | mstore(0x20, p0) |
| 10392 | mstore(0x40, 0x80) |
| 10393 | mstore(0x60, p2) |
| 10394 | mstore(0x80, p3) |
| 10395 | writeString(0xa0, p1) |
| 10396 | } |
| 10397 | _sendLogPayload(0x1c, 0xc4); |
| 10398 | /// @solidity memory-safe-assembly |
| 10399 | assembly { |
| 10400 | mstore(0x00, m0) |
| 10401 | mstore(0x20, m1) |
| 10402 | mstore(0x40, m2) |
| 10403 | mstore(0x60, m3) |
| 10404 | mstore(0x80, m4) |
| 10405 | mstore(0xa0, m5) |
| 10406 | mstore(0xc0, m6) |
| 10407 | } |
| 10408 | } |
| 10409 | |
| 10410 | function log(uint256 p0, bytes32 p1, uint256 p2, uint256 p3) internal pure { |
| 10411 | bytes32 m0; |
| 10412 | bytes32 m1; |
| 10413 | bytes32 m2; |
| 10414 | bytes32 m3; |
| 10415 | bytes32 m4; |
| 10416 | bytes32 m5; |
| 10417 | bytes32 m6; |
| 10418 | /// @solidity memory-safe-assembly |
| 10419 | assembly { |
| 10420 | function writeString(pos, w) { |
| 10421 | let length := 0 |
| 10422 | for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } |
| 10423 | mstore(pos, length) |
| 10424 | let shift := sub(256, shl(3, length)) |
| 10425 | mstore(add(pos, 0x20), shl(shift, shr(shift, w))) |
| 10426 | } |
| 10427 | m0 := mload(0x00) |
| 10428 | m1 := mload(0x20) |
| 10429 | m2 := mload(0x40) |
| 10430 | m3 := mload(0x60) |
| 10431 | m4 := mload(0x80) |
| 10432 | m5 := mload(0xa0) |
| 10433 | m6 := mload(0xc0) |
| 10434 | // Selector of `log(uint256,string,uint256,uint256)`. |
| 10435 | mstore(0x00, 0x82c25b74) |
| 10436 | mstore(0x20, p0) |
| 10437 | mstore(0x40, 0x80) |
| 10438 | mstore(0x60, p2) |
| 10439 | mstore(0x80, p3) |
| 10440 | writeString(0xa0, p1) |
| 10441 | } |
| 10442 | _sendLogPayload(0x1c, 0xc4); |
| 10443 | /// @solidity memory-safe-assembly |
| 10444 | assembly { |
| 10445 | mstore(0x00, m0) |
| 10446 | mstore(0x20, m1) |
| 10447 | mstore(0x40, m2) |
| 10448 | mstore(0x60, m3) |
| 10449 | mstore(0x80, m4) |
| 10450 | mstore(0xa0, m5) |
| 10451 | mstore(0xc0, m6) |
| 10452 | } |
| 10453 | } |
| 10454 | |
| 10455 | function log(uint256 p0, bytes32 p1, uint256 p2, bytes32 p3) internal pure { |
| 10456 | bytes32 m0; |
| 10457 | bytes32 m1; |
| 10458 | bytes32 m2; |
| 10459 | bytes32 m3; |
| 10460 | bytes32 m4; |
| 10461 | bytes32 m5; |
| 10462 | bytes32 m6; |
| 10463 | bytes32 m7; |
| 10464 | bytes32 m8; |
| 10465 | /// @solidity memory-safe-assembly |
| 10466 | assembly { |
| 10467 | function writeString(pos, w) { |
| 10468 | let length := 0 |
| 10469 | for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } |
| 10470 | mstore(pos, length) |
| 10471 | let shift := sub(256, shl(3, length)) |
| 10472 | mstore(add(pos, 0x20), shl(shift, shr(shift, w))) |
| 10473 | } |
| 10474 | m0 := mload(0x00) |
| 10475 | m1 := mload(0x20) |
| 10476 | m2 := mload(0x40) |
| 10477 | m3 := mload(0x60) |
| 10478 | m4 := mload(0x80) |
| 10479 | m5 := mload(0xa0) |
| 10480 | m6 := mload(0xc0) |
| 10481 | m7 := mload(0xe0) |
| 10482 | m8 := mload(0x100) |
| 10483 | // Selector of `log(uint256,string,uint256,string)`. |
| 10484 | mstore(0x00, 0xb7b914ca) |
| 10485 | mstore(0x20, p0) |
| 10486 | mstore(0x40, 0x80) |
| 10487 | mstore(0x60, p2) |
| 10488 | mstore(0x80, 0xc0) |
| 10489 | writeString(0xa0, p1) |
| 10490 | writeString(0xe0, p3) |
| 10491 | } |
| 10492 | _sendLogPayload(0x1c, 0x104); |
| 10493 | /// @solidity memory-safe-assembly |
| 10494 | assembly { |
| 10495 | mstore(0x00, m0) |
| 10496 | mstore(0x20, m1) |
| 10497 | mstore(0x40, m2) |
| 10498 | mstore(0x60, m3) |
| 10499 | mstore(0x80, m4) |
| 10500 | mstore(0xa0, m5) |
| 10501 | mstore(0xc0, m6) |
| 10502 | mstore(0xe0, m7) |
| 10503 | mstore(0x100, m8) |
| 10504 | } |
| 10505 | } |
| 10506 | |
| 10507 | function log(uint256 p0, bytes32 p1, bytes32 p2, address p3) internal pure { |
| 10508 | bytes32 m0; |
| 10509 | bytes32 m1; |
| 10510 | bytes32 m2; |
| 10511 | bytes32 m3; |
| 10512 | bytes32 m4; |
| 10513 | bytes32 m5; |
| 10514 | bytes32 m6; |
| 10515 | bytes32 m7; |
| 10516 | bytes32 m8; |
| 10517 | /// @solidity memory-safe-assembly |
| 10518 | assembly { |
| 10519 | function writeString(pos, w) { |
| 10520 | let length := 0 |
| 10521 | for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } |
| 10522 | mstore(pos, length) |
| 10523 | let shift := sub(256, shl(3, length)) |
| 10524 | mstore(add(pos, 0x20), shl(shift, shr(shift, w))) |
| 10525 | } |
| 10526 | m0 := mload(0x00) |
| 10527 | m1 := mload(0x20) |
| 10528 | m2 := mload(0x40) |
| 10529 | m3 := mload(0x60) |
| 10530 | m4 := mload(0x80) |
| 10531 | m5 := mload(0xa0) |
| 10532 | m6 := mload(0xc0) |
| 10533 | m7 := mload(0xe0) |
| 10534 | m8 := mload(0x100) |
| 10535 | // Selector of `log(uint256,string,string,address)`. |
| 10536 | mstore(0x00, 0xd583c602) |
| 10537 | mstore(0x20, p0) |
| 10538 | mstore(0x40, 0x80) |
| 10539 | mstore(0x60, 0xc0) |
| 10540 | mstore(0x80, p3) |
| 10541 | writeString(0xa0, p1) |
| 10542 | writeString(0xe0, p2) |
| 10543 | } |
| 10544 | _sendLogPayload(0x1c, 0x104); |
| 10545 | /// @solidity memory-safe-assembly |
| 10546 | assembly { |
| 10547 | mstore(0x00, m0) |
| 10548 | mstore(0x20, m1) |
| 10549 | mstore(0x40, m2) |
| 10550 | mstore(0x60, m3) |
| 10551 | mstore(0x80, m4) |
| 10552 | mstore(0xa0, m5) |
| 10553 | mstore(0xc0, m6) |
| 10554 | mstore(0xe0, m7) |
| 10555 | mstore(0x100, m8) |
| 10556 | } |
| 10557 | } |
| 10558 | |
| 10559 | function log(uint256 p0, bytes32 p1, bytes32 p2, bool p3) internal pure { |
| 10560 | bytes32 m0; |
| 10561 | bytes32 m1; |
| 10562 | bytes32 m2; |
| 10563 | bytes32 m3; |
| 10564 | bytes32 m4; |
| 10565 | bytes32 m5; |
| 10566 | bytes32 m6; |
| 10567 | bytes32 m7; |
| 10568 | bytes32 m8; |
| 10569 | /// @solidity memory-safe-assembly |
| 10570 | assembly { |
| 10571 | function writeString(pos, w) { |
| 10572 | let length := 0 |
| 10573 | for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } |
| 10574 | mstore(pos, length) |
| 10575 | let shift := sub(256, shl(3, length)) |
| 10576 | mstore(add(pos, 0x20), shl(shift, shr(shift, w))) |
| 10577 | } |
| 10578 | m0 := mload(0x00) |
| 10579 | m1 := mload(0x20) |
| 10580 | m2 := mload(0x40) |
| 10581 | m3 := mload(0x60) |
| 10582 | m4 := mload(0x80) |
| 10583 | m5 := mload(0xa0) |
| 10584 | m6 := mload(0xc0) |
| 10585 | m7 := mload(0xe0) |
| 10586 | m8 := mload(0x100) |
| 10587 | // Selector of `log(uint256,string,string,bool)`. |
| 10588 | mstore(0x00, 0xb3a6b6bd) |
| 10589 | mstore(0x20, p0) |
| 10590 | mstore(0x40, 0x80) |
| 10591 | mstore(0x60, 0xc0) |
| 10592 | mstore(0x80, p3) |
| 10593 | writeString(0xa0, p1) |
| 10594 | writeString(0xe0, p2) |
| 10595 | } |
| 10596 | _sendLogPayload(0x1c, 0x104); |
| 10597 | /// @solidity memory-safe-assembly |
| 10598 | assembly { |
| 10599 | mstore(0x00, m0) |
| 10600 | mstore(0x20, m1) |
| 10601 | mstore(0x40, m2) |
| 10602 | mstore(0x60, m3) |
| 10603 | mstore(0x80, m4) |
| 10604 | mstore(0xa0, m5) |
| 10605 | mstore(0xc0, m6) |
| 10606 | mstore(0xe0, m7) |
| 10607 | mstore(0x100, m8) |
| 10608 | } |
| 10609 | } |
| 10610 | |
| 10611 | function log(uint256 p0, bytes32 p1, bytes32 p2, uint256 p3) internal pure { |
| 10612 | bytes32 m0; |
| 10613 | bytes32 m1; |
| 10614 | bytes32 m2; |
| 10615 | bytes32 m3; |
| 10616 | bytes32 m4; |
| 10617 | bytes32 m5; |
| 10618 | bytes32 m6; |
| 10619 | bytes32 m7; |
| 10620 | bytes32 m8; |
| 10621 | /// @solidity memory-safe-assembly |
| 10622 | assembly { |
| 10623 | function writeString(pos, w) { |
| 10624 | let length := 0 |
| 10625 | for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } |
| 10626 | mstore(pos, length) |
| 10627 | let shift := sub(256, shl(3, length)) |
| 10628 | mstore(add(pos, 0x20), shl(shift, shr(shift, w))) |
| 10629 | } |
| 10630 | m0 := mload(0x00) |
| 10631 | m1 := mload(0x20) |
| 10632 | m2 := mload(0x40) |
| 10633 | m3 := mload(0x60) |
| 10634 | m4 := mload(0x80) |
| 10635 | m5 := mload(0xa0) |
| 10636 | m6 := mload(0xc0) |
| 10637 | m7 := mload(0xe0) |
| 10638 | m8 := mload(0x100) |
| 10639 | // Selector of `log(uint256,string,string,uint256)`. |
| 10640 | mstore(0x00, 0xb028c9bd) |
| 10641 | mstore(0x20, p0) |
| 10642 | mstore(0x40, 0x80) |
| 10643 | mstore(0x60, 0xc0) |
| 10644 | mstore(0x80, p3) |
| 10645 | writeString(0xa0, p1) |
| 10646 | writeString(0xe0, p2) |
| 10647 | } |
| 10648 | _sendLogPayload(0x1c, 0x104); |
| 10649 | /// @solidity memory-safe-assembly |
| 10650 | assembly { |
| 10651 | mstore(0x00, m0) |
| 10652 | mstore(0x20, m1) |
| 10653 | mstore(0x40, m2) |
| 10654 | mstore(0x60, m3) |
| 10655 | mstore(0x80, m4) |
| 10656 | mstore(0xa0, m5) |
| 10657 | mstore(0xc0, m6) |
| 10658 | mstore(0xe0, m7) |
| 10659 | mstore(0x100, m8) |
| 10660 | } |
| 10661 | } |
| 10662 | |
| 10663 | function log(uint256 p0, bytes32 p1, bytes32 p2, bytes32 p3) internal pure { |
| 10664 | bytes32 m0; |
| 10665 | bytes32 m1; |
| 10666 | bytes32 m2; |
| 10667 | bytes32 m3; |
| 10668 | bytes32 m4; |
| 10669 | bytes32 m5; |
| 10670 | bytes32 m6; |
| 10671 | bytes32 m7; |
| 10672 | bytes32 m8; |
| 10673 | bytes32 m9; |
| 10674 | bytes32 m10; |
| 10675 | /// @solidity memory-safe-assembly |
| 10676 | assembly { |
| 10677 | function writeString(pos, w) { |
| 10678 | let length := 0 |
| 10679 | for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } |
| 10680 | mstore(pos, length) |
| 10681 | let shift := sub(256, shl(3, length)) |
| 10682 | mstore(add(pos, 0x20), shl(shift, shr(shift, w))) |
| 10683 | } |
| 10684 | m0 := mload(0x00) |
| 10685 | m1 := mload(0x20) |
| 10686 | m2 := mload(0x40) |
| 10687 | m3 := mload(0x60) |
| 10688 | m4 := mload(0x80) |
| 10689 | m5 := mload(0xa0) |
| 10690 | m6 := mload(0xc0) |
| 10691 | m7 := mload(0xe0) |
| 10692 | m8 := mload(0x100) |
| 10693 | m9 := mload(0x120) |
| 10694 | m10 := mload(0x140) |
| 10695 | // Selector of `log(uint256,string,string,string)`. |
| 10696 | mstore(0x00, 0x21ad0683) |
| 10697 | mstore(0x20, p0) |
| 10698 | mstore(0x40, 0x80) |
| 10699 | mstore(0x60, 0xc0) |
| 10700 | mstore(0x80, 0x100) |
| 10701 | writeString(0xa0, p1) |
| 10702 | writeString(0xe0, p2) |
| 10703 | writeString(0x120, p3) |
| 10704 | } |
| 10705 | _sendLogPayload(0x1c, 0x144); |
| 10706 | /// @solidity memory-safe-assembly |
| 10707 | assembly { |
| 10708 | mstore(0x00, m0) |
| 10709 | mstore(0x20, m1) |
| 10710 | mstore(0x40, m2) |
| 10711 | mstore(0x60, m3) |
| 10712 | mstore(0x80, m4) |
| 10713 | mstore(0xa0, m5) |
| 10714 | mstore(0xc0, m6) |
| 10715 | mstore(0xe0, m7) |
| 10716 | mstore(0x100, m8) |
| 10717 | mstore(0x120, m9) |
| 10718 | mstore(0x140, m10) |
| 10719 | } |
| 10720 | } |
| 10721 | |
| 10722 | function log(bytes32 p0, address p1, address p2, address p3) internal pure { |
| 10723 | bytes32 m0; |
| 10724 | bytes32 m1; |
| 10725 | bytes32 m2; |
| 10726 | bytes32 m3; |
| 10727 | bytes32 m4; |
| 10728 | bytes32 m5; |
| 10729 | bytes32 m6; |
| 10730 | /// @solidity memory-safe-assembly |
| 10731 | assembly { |
| 10732 | function writeString(pos, w) { |
| 10733 | let length := 0 |
| 10734 | for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } |
| 10735 | mstore(pos, length) |
| 10736 | let shift := sub(256, shl(3, length)) |
| 10737 | mstore(add(pos, 0x20), shl(shift, shr(shift, w))) |
| 10738 | } |
| 10739 | m0 := mload(0x00) |
| 10740 | m1 := mload(0x20) |
| 10741 | m2 := mload(0x40) |
| 10742 | m3 := mload(0x60) |
| 10743 | m4 := mload(0x80) |
| 10744 | m5 := mload(0xa0) |
| 10745 | m6 := mload(0xc0) |
| 10746 | // Selector of `log(string,address,address,address)`. |
| 10747 | mstore(0x00, 0xed8f28f6) |
| 10748 | mstore(0x20, 0x80) |
| 10749 | mstore(0x40, p1) |
| 10750 | mstore(0x60, p2) |
| 10751 | mstore(0x80, p3) |
| 10752 | writeString(0xa0, p0) |
| 10753 | } |
| 10754 | _sendLogPayload(0x1c, 0xc4); |
| 10755 | /// @solidity memory-safe-assembly |
| 10756 | assembly { |
| 10757 | mstore(0x00, m0) |
| 10758 | mstore(0x20, m1) |
| 10759 | mstore(0x40, m2) |
| 10760 | mstore(0x60, m3) |
| 10761 | mstore(0x80, m4) |
| 10762 | mstore(0xa0, m5) |
| 10763 | mstore(0xc0, m6) |
| 10764 | } |
| 10765 | } |
| 10766 | |
| 10767 | function log(bytes32 p0, address p1, address p2, bool p3) internal pure { |
| 10768 | bytes32 m0; |
| 10769 | bytes32 m1; |
| 10770 | bytes32 m2; |
| 10771 | bytes32 m3; |
| 10772 | bytes32 m4; |
| 10773 | bytes32 m5; |
| 10774 | bytes32 m6; |
| 10775 | /// @solidity memory-safe-assembly |
| 10776 | assembly { |
| 10777 | function writeString(pos, w) { |
| 10778 | let length := 0 |
| 10779 | for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } |
| 10780 | mstore(pos, length) |
| 10781 | let shift := sub(256, shl(3, length)) |
| 10782 | mstore(add(pos, 0x20), shl(shift, shr(shift, w))) |
| 10783 | } |
| 10784 | m0 := mload(0x00) |
| 10785 | m1 := mload(0x20) |
| 10786 | m2 := mload(0x40) |
| 10787 | m3 := mload(0x60) |
| 10788 | m4 := mload(0x80) |
| 10789 | m5 := mload(0xa0) |
| 10790 | m6 := mload(0xc0) |
| 10791 | // Selector of `log(string,address,address,bool)`. |
| 10792 | mstore(0x00, 0xb59dbd60) |
| 10793 | mstore(0x20, 0x80) |
| 10794 | mstore(0x40, p1) |
| 10795 | mstore(0x60, p2) |
| 10796 | mstore(0x80, p3) |
| 10797 | writeString(0xa0, p0) |
| 10798 | } |
| 10799 | _sendLogPayload(0x1c, 0xc4); |
| 10800 | /// @solidity memory-safe-assembly |
| 10801 | assembly { |
| 10802 | mstore(0x00, m0) |
| 10803 | mstore(0x20, m1) |
| 10804 | mstore(0x40, m2) |
| 10805 | mstore(0x60, m3) |
| 10806 | mstore(0x80, m4) |
| 10807 | mstore(0xa0, m5) |
| 10808 | mstore(0xc0, m6) |
| 10809 | } |
| 10810 | } |
| 10811 | |
| 10812 | function log(bytes32 p0, address p1, address p2, uint256 p3) internal pure { |
| 10813 | bytes32 m0; |
| 10814 | bytes32 m1; |
| 10815 | bytes32 m2; |
| 10816 | bytes32 m3; |
| 10817 | bytes32 m4; |
| 10818 | bytes32 m5; |
| 10819 | bytes32 m6; |
| 10820 | /// @solidity memory-safe-assembly |
| 10821 | assembly { |
| 10822 | function writeString(pos, w) { |
| 10823 | let length := 0 |
| 10824 | for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } |
| 10825 | mstore(pos, length) |
| 10826 | let shift := sub(256, shl(3, length)) |
| 10827 | mstore(add(pos, 0x20), shl(shift, shr(shift, w))) |
| 10828 | } |
| 10829 | m0 := mload(0x00) |
| 10830 | m1 := mload(0x20) |
| 10831 | m2 := mload(0x40) |
| 10832 | m3 := mload(0x60) |
| 10833 | m4 := mload(0x80) |
| 10834 | m5 := mload(0xa0) |
| 10835 | m6 := mload(0xc0) |
| 10836 | // Selector of `log(string,address,address,uint256)`. |
| 10837 | mstore(0x00, 0x8ef3f399) |
| 10838 | mstore(0x20, 0x80) |
| 10839 | mstore(0x40, p1) |
| 10840 | mstore(0x60, p2) |
| 10841 | mstore(0x80, p3) |
| 10842 | writeString(0xa0, p0) |
| 10843 | } |
| 10844 | _sendLogPayload(0x1c, 0xc4); |
| 10845 | /// @solidity memory-safe-assembly |
| 10846 | assembly { |
| 10847 | mstore(0x00, m0) |
| 10848 | mstore(0x20, m1) |
| 10849 | mstore(0x40, m2) |
| 10850 | mstore(0x60, m3) |
| 10851 | mstore(0x80, m4) |
| 10852 | mstore(0xa0, m5) |
| 10853 | mstore(0xc0, m6) |
| 10854 | } |
| 10855 | } |
| 10856 | |
| 10857 | function log(bytes32 p0, address p1, address p2, bytes32 p3) internal pure { |
| 10858 | bytes32 m0; |
| 10859 | bytes32 m1; |
| 10860 | bytes32 m2; |
| 10861 | bytes32 m3; |
| 10862 | bytes32 m4; |
| 10863 | bytes32 m5; |
| 10864 | bytes32 m6; |
| 10865 | bytes32 m7; |
| 10866 | bytes32 m8; |
| 10867 | /// @solidity memory-safe-assembly |
| 10868 | assembly { |
| 10869 | function writeString(pos, w) { |
| 10870 | let length := 0 |
| 10871 | for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } |
| 10872 | mstore(pos, length) |
| 10873 | let shift := sub(256, shl(3, length)) |
| 10874 | mstore(add(pos, 0x20), shl(shift, shr(shift, w))) |
| 10875 | } |
| 10876 | m0 := mload(0x00) |
| 10877 | m1 := mload(0x20) |
| 10878 | m2 := mload(0x40) |
| 10879 | m3 := mload(0x60) |
| 10880 | m4 := mload(0x80) |
| 10881 | m5 := mload(0xa0) |
| 10882 | m6 := mload(0xc0) |
| 10883 | m7 := mload(0xe0) |
| 10884 | m8 := mload(0x100) |
| 10885 | // Selector of `log(string,address,address,string)`. |
| 10886 | mstore(0x00, 0x800a1c67) |
| 10887 | mstore(0x20, 0x80) |
| 10888 | mstore(0x40, p1) |
| 10889 | mstore(0x60, p2) |
| 10890 | mstore(0x80, 0xc0) |
| 10891 | writeString(0xa0, p0) |
| 10892 | writeString(0xe0, p3) |
| 10893 | } |
| 10894 | _sendLogPayload(0x1c, 0x104); |
| 10895 | /// @solidity memory-safe-assembly |
| 10896 | assembly { |
| 10897 | mstore(0x00, m0) |
| 10898 | mstore(0x20, m1) |
| 10899 | mstore(0x40, m2) |
| 10900 | mstore(0x60, m3) |
| 10901 | mstore(0x80, m4) |
| 10902 | mstore(0xa0, m5) |
| 10903 | mstore(0xc0, m6) |
| 10904 | mstore(0xe0, m7) |
| 10905 | mstore(0x100, m8) |
| 10906 | } |
| 10907 | } |
| 10908 | |
| 10909 | function log(bytes32 p0, address p1, bool p2, address p3) internal pure { |
| 10910 | bytes32 m0; |
| 10911 | bytes32 m1; |
| 10912 | bytes32 m2; |
| 10913 | bytes32 m3; |
| 10914 | bytes32 m4; |
| 10915 | bytes32 m5; |
| 10916 | bytes32 m6; |
| 10917 | /// @solidity memory-safe-assembly |
| 10918 | assembly { |
| 10919 | function writeString(pos, w) { |
| 10920 | let length := 0 |
| 10921 | for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } |
| 10922 | mstore(pos, length) |
| 10923 | let shift := sub(256, shl(3, length)) |
| 10924 | mstore(add(pos, 0x20), shl(shift, shr(shift, w))) |
| 10925 | } |
| 10926 | m0 := mload(0x00) |
| 10927 | m1 := mload(0x20) |
| 10928 | m2 := mload(0x40) |
| 10929 | m3 := mload(0x60) |
| 10930 | m4 := mload(0x80) |
| 10931 | m5 := mload(0xa0) |
| 10932 | m6 := mload(0xc0) |
| 10933 | // Selector of `log(string,address,bool,address)`. |
| 10934 | mstore(0x00, 0x223603bd) |
| 10935 | mstore(0x20, 0x80) |
| 10936 | mstore(0x40, p1) |
| 10937 | mstore(0x60, p2) |
| 10938 | mstore(0x80, p3) |
| 10939 | writeString(0xa0, p0) |
| 10940 | } |
| 10941 | _sendLogPayload(0x1c, 0xc4); |
| 10942 | /// @solidity memory-safe-assembly |
| 10943 | assembly { |
| 10944 | mstore(0x00, m0) |
| 10945 | mstore(0x20, m1) |
| 10946 | mstore(0x40, m2) |
| 10947 | mstore(0x60, m3) |
| 10948 | mstore(0x80, m4) |
| 10949 | mstore(0xa0, m5) |
| 10950 | mstore(0xc0, m6) |
| 10951 | } |
| 10952 | } |
| 10953 | |
| 10954 | function log(bytes32 p0, address p1, bool p2, bool p3) internal pure { |
| 10955 | bytes32 m0; |
| 10956 | bytes32 m1; |
| 10957 | bytes32 m2; |
| 10958 | bytes32 m3; |
| 10959 | bytes32 m4; |
| 10960 | bytes32 m5; |
| 10961 | bytes32 m6; |
| 10962 | /// @solidity memory-safe-assembly |
| 10963 | assembly { |
| 10964 | function writeString(pos, w) { |
| 10965 | let length := 0 |
| 10966 | for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } |
| 10967 | mstore(pos, length) |
| 10968 | let shift := sub(256, shl(3, length)) |
| 10969 | mstore(add(pos, 0x20), shl(shift, shr(shift, w))) |
| 10970 | } |
| 10971 | m0 := mload(0x00) |
| 10972 | m1 := mload(0x20) |
| 10973 | m2 := mload(0x40) |
| 10974 | m3 := mload(0x60) |
| 10975 | m4 := mload(0x80) |
| 10976 | m5 := mload(0xa0) |
| 10977 | m6 := mload(0xc0) |
| 10978 | // Selector of `log(string,address,bool,bool)`. |
| 10979 | mstore(0x00, 0x79884c2b) |
| 10980 | mstore(0x20, 0x80) |
| 10981 | mstore(0x40, p1) |
| 10982 | mstore(0x60, p2) |
| 10983 | mstore(0x80, p3) |
| 10984 | writeString(0xa0, p0) |
| 10985 | } |
| 10986 | _sendLogPayload(0x1c, 0xc4); |
| 10987 | /// @solidity memory-safe-assembly |
| 10988 | assembly { |
| 10989 | mstore(0x00, m0) |
| 10990 | mstore(0x20, m1) |
| 10991 | mstore(0x40, m2) |
| 10992 | mstore(0x60, m3) |
| 10993 | mstore(0x80, m4) |
| 10994 | mstore(0xa0, m5) |
| 10995 | mstore(0xc0, m6) |
| 10996 | } |
| 10997 | } |
| 10998 | |
| 10999 | function log(bytes32 p0, address p1, bool p2, uint256 p3) internal pure { |
| 11000 | bytes32 m0; |
| 11001 | bytes32 m1; |
| 11002 | bytes32 m2; |
| 11003 | bytes32 m3; |
| 11004 | bytes32 m4; |
| 11005 | bytes32 m5; |
| 11006 | bytes32 m6; |
| 11007 | /// @solidity memory-safe-assembly |
| 11008 | assembly { |
| 11009 | function writeString(pos, w) { |
| 11010 | let length := 0 |
| 11011 | for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } |
| 11012 | mstore(pos, length) |
| 11013 | let shift := sub(256, shl(3, length)) |
| 11014 | mstore(add(pos, 0x20), shl(shift, shr(shift, w))) |
| 11015 | } |
| 11016 | m0 := mload(0x00) |
| 11017 | m1 := mload(0x20) |
| 11018 | m2 := mload(0x40) |
| 11019 | m3 := mload(0x60) |
| 11020 | m4 := mload(0x80) |
| 11021 | m5 := mload(0xa0) |
| 11022 | m6 := mload(0xc0) |
| 11023 | // Selector of `log(string,address,bool,uint256)`. |
| 11024 | mstore(0x00, 0x3e9f866a) |
| 11025 | mstore(0x20, 0x80) |
| 11026 | mstore(0x40, p1) |
| 11027 | mstore(0x60, p2) |
| 11028 | mstore(0x80, p3) |
| 11029 | writeString(0xa0, p0) |
| 11030 | } |
| 11031 | _sendLogPayload(0x1c, 0xc4); |
| 11032 | /// @solidity memory-safe-assembly |
| 11033 | assembly { |
| 11034 | mstore(0x00, m0) |
| 11035 | mstore(0x20, m1) |
| 11036 | mstore(0x40, m2) |
| 11037 | mstore(0x60, m3) |
| 11038 | mstore(0x80, m4) |
| 11039 | mstore(0xa0, m5) |
| 11040 | mstore(0xc0, m6) |
| 11041 | } |
| 11042 | } |
| 11043 | |
| 11044 | function log(bytes32 p0, address p1, bool p2, bytes32 p3) internal pure { |
| 11045 | bytes32 m0; |
| 11046 | bytes32 m1; |
| 11047 | bytes32 m2; |
| 11048 | bytes32 m3; |
| 11049 | bytes32 m4; |
| 11050 | bytes32 m5; |
| 11051 | bytes32 m6; |
| 11052 | bytes32 m7; |
| 11053 | bytes32 m8; |
| 11054 | /// @solidity memory-safe-assembly |
| 11055 | assembly { |
| 11056 | function writeString(pos, w) { |
| 11057 | let length := 0 |
| 11058 | for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } |
| 11059 | mstore(pos, length) |
| 11060 | let shift := sub(256, shl(3, length)) |
| 11061 | mstore(add(pos, 0x20), shl(shift, shr(shift, w))) |
| 11062 | } |
| 11063 | m0 := mload(0x00) |
| 11064 | m1 := mload(0x20) |
| 11065 | m2 := mload(0x40) |
| 11066 | m3 := mload(0x60) |
| 11067 | m4 := mload(0x80) |
| 11068 | m5 := mload(0xa0) |
| 11069 | m6 := mload(0xc0) |
| 11070 | m7 := mload(0xe0) |
| 11071 | m8 := mload(0x100) |
| 11072 | // Selector of `log(string,address,bool,string)`. |
| 11073 | mstore(0x00, 0x0454c079) |
| 11074 | mstore(0x20, 0x80) |
| 11075 | mstore(0x40, p1) |
| 11076 | mstore(0x60, p2) |
| 11077 | mstore(0x80, 0xc0) |
| 11078 | writeString(0xa0, p0) |
| 11079 | writeString(0xe0, p3) |
| 11080 | } |
| 11081 | _sendLogPayload(0x1c, 0x104); |
| 11082 | /// @solidity memory-safe-assembly |
| 11083 | assembly { |
| 11084 | mstore(0x00, m0) |
| 11085 | mstore(0x20, m1) |
| 11086 | mstore(0x40, m2) |
| 11087 | mstore(0x60, m3) |
| 11088 | mstore(0x80, m4) |
| 11089 | mstore(0xa0, m5) |
| 11090 | mstore(0xc0, m6) |
| 11091 | mstore(0xe0, m7) |
| 11092 | mstore(0x100, m8) |
| 11093 | } |
| 11094 | } |
| 11095 | |
| 11096 | function log(bytes32 p0, address p1, uint256 p2, address p3) internal pure { |
| 11097 | bytes32 m0; |
| 11098 | bytes32 m1; |
| 11099 | bytes32 m2; |
| 11100 | bytes32 m3; |
| 11101 | bytes32 m4; |
| 11102 | bytes32 m5; |
| 11103 | bytes32 m6; |
| 11104 | /// @solidity memory-safe-assembly |
| 11105 | assembly { |
| 11106 | function writeString(pos, w) { |
| 11107 | let length := 0 |
| 11108 | for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } |
| 11109 | mstore(pos, length) |
| 11110 | let shift := sub(256, shl(3, length)) |
| 11111 | mstore(add(pos, 0x20), shl(shift, shr(shift, w))) |
| 11112 | } |
| 11113 | m0 := mload(0x00) |
| 11114 | m1 := mload(0x20) |
| 11115 | m2 := mload(0x40) |
| 11116 | m3 := mload(0x60) |
| 11117 | m4 := mload(0x80) |
| 11118 | m5 := mload(0xa0) |
| 11119 | m6 := mload(0xc0) |
| 11120 | // Selector of `log(string,address,uint256,address)`. |
| 11121 | mstore(0x00, 0x63fb8bc5) |
| 11122 | mstore(0x20, 0x80) |
| 11123 | mstore(0x40, p1) |
| 11124 | mstore(0x60, p2) |
| 11125 | mstore(0x80, p3) |
| 11126 | writeString(0xa0, p0) |
| 11127 | } |
| 11128 | _sendLogPayload(0x1c, 0xc4); |
| 11129 | /// @solidity memory-safe-assembly |
| 11130 | assembly { |
| 11131 | mstore(0x00, m0) |
| 11132 | mstore(0x20, m1) |
| 11133 | mstore(0x40, m2) |
| 11134 | mstore(0x60, m3) |
| 11135 | mstore(0x80, m4) |
| 11136 | mstore(0xa0, m5) |
| 11137 | mstore(0xc0, m6) |
| 11138 | } |
| 11139 | } |
| 11140 | |
| 11141 | function log(bytes32 p0, address p1, uint256 p2, bool p3) internal pure { |
| 11142 | bytes32 m0; |
| 11143 | bytes32 m1; |
| 11144 | bytes32 m2; |
| 11145 | bytes32 m3; |
| 11146 | bytes32 m4; |
| 11147 | bytes32 m5; |
| 11148 | bytes32 m6; |
| 11149 | /// @solidity memory-safe-assembly |
| 11150 | assembly { |
| 11151 | function writeString(pos, w) { |
| 11152 | let length := 0 |
| 11153 | for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } |
| 11154 | mstore(pos, length) |
| 11155 | let shift := sub(256, shl(3, length)) |
| 11156 | mstore(add(pos, 0x20), shl(shift, shr(shift, w))) |
| 11157 | } |
| 11158 | m0 := mload(0x00) |
| 11159 | m1 := mload(0x20) |
| 11160 | m2 := mload(0x40) |
| 11161 | m3 := mload(0x60) |
| 11162 | m4 := mload(0x80) |
| 11163 | m5 := mload(0xa0) |
| 11164 | m6 := mload(0xc0) |
| 11165 | // Selector of `log(string,address,uint256,bool)`. |
| 11166 | mstore(0x00, 0xfc4845f0) |
| 11167 | mstore(0x20, 0x80) |
| 11168 | mstore(0x40, p1) |
| 11169 | mstore(0x60, p2) |
| 11170 | mstore(0x80, p3) |
| 11171 | writeString(0xa0, p0) |
| 11172 | } |
| 11173 | _sendLogPayload(0x1c, 0xc4); |
| 11174 | /// @solidity memory-safe-assembly |
| 11175 | assembly { |
| 11176 | mstore(0x00, m0) |
| 11177 | mstore(0x20, m1) |
| 11178 | mstore(0x40, m2) |
| 11179 | mstore(0x60, m3) |
| 11180 | mstore(0x80, m4) |
| 11181 | mstore(0xa0, m5) |
| 11182 | mstore(0xc0, m6) |
| 11183 | } |
| 11184 | } |
| 11185 | |
| 11186 | function log(bytes32 p0, address p1, uint256 p2, uint256 p3) internal pure { |
| 11187 | bytes32 m0; |
| 11188 | bytes32 m1; |
| 11189 | bytes32 m2; |
| 11190 | bytes32 m3; |
| 11191 | bytes32 m4; |
| 11192 | bytes32 m5; |
| 11193 | bytes32 m6; |
| 11194 | /// @solidity memory-safe-assembly |
| 11195 | assembly { |
| 11196 | function writeString(pos, w) { |
| 11197 | let length := 0 |
| 11198 | for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } |
| 11199 | mstore(pos, length) |
| 11200 | let shift := sub(256, shl(3, length)) |
| 11201 | mstore(add(pos, 0x20), shl(shift, shr(shift, w))) |
| 11202 | } |
| 11203 | m0 := mload(0x00) |
| 11204 | m1 := mload(0x20) |
| 11205 | m2 := mload(0x40) |
| 11206 | m3 := mload(0x60) |
| 11207 | m4 := mload(0x80) |
| 11208 | m5 := mload(0xa0) |
| 11209 | m6 := mload(0xc0) |
| 11210 | // Selector of `log(string,address,uint256,uint256)`. |
| 11211 | mstore(0x00, 0xf8f51b1e) |
| 11212 | mstore(0x20, 0x80) |
| 11213 | mstore(0x40, p1) |
| 11214 | mstore(0x60, p2) |
| 11215 | mstore(0x80, p3) |
| 11216 | writeString(0xa0, p0) |
| 11217 | } |
| 11218 | _sendLogPayload(0x1c, 0xc4); |
| 11219 | /// @solidity memory-safe-assembly |
| 11220 | assembly { |
| 11221 | mstore(0x00, m0) |
| 11222 | mstore(0x20, m1) |
| 11223 | mstore(0x40, m2) |
| 11224 | mstore(0x60, m3) |
| 11225 | mstore(0x80, m4) |
| 11226 | mstore(0xa0, m5) |
| 11227 | mstore(0xc0, m6) |
| 11228 | } |
| 11229 | } |
| 11230 | |
| 11231 | function log(bytes32 p0, address p1, uint256 p2, bytes32 p3) internal pure { |
| 11232 | bytes32 m0; |
| 11233 | bytes32 m1; |
| 11234 | bytes32 m2; |
| 11235 | bytes32 m3; |
| 11236 | bytes32 m4; |
| 11237 | bytes32 m5; |
| 11238 | bytes32 m6; |
| 11239 | bytes32 m7; |
| 11240 | bytes32 m8; |
| 11241 | /// @solidity memory-safe-assembly |
| 11242 | assembly { |
| 11243 | function writeString(pos, w) { |
| 11244 | let length := 0 |
| 11245 | for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } |
| 11246 | mstore(pos, length) |
| 11247 | let shift := sub(256, shl(3, length)) |
| 11248 | mstore(add(pos, 0x20), shl(shift, shr(shift, w))) |
| 11249 | } |
| 11250 | m0 := mload(0x00) |
| 11251 | m1 := mload(0x20) |
| 11252 | m2 := mload(0x40) |
| 11253 | m3 := mload(0x60) |
| 11254 | m4 := mload(0x80) |
| 11255 | m5 := mload(0xa0) |
| 11256 | m6 := mload(0xc0) |
| 11257 | m7 := mload(0xe0) |
| 11258 | m8 := mload(0x100) |
| 11259 | // Selector of `log(string,address,uint256,string)`. |
| 11260 | mstore(0x00, 0x5a477632) |
| 11261 | mstore(0x20, 0x80) |
| 11262 | mstore(0x40, p1) |
| 11263 | mstore(0x60, p2) |
| 11264 | mstore(0x80, 0xc0) |
| 11265 | writeString(0xa0, p0) |
| 11266 | writeString(0xe0, p3) |
| 11267 | } |
| 11268 | _sendLogPayload(0x1c, 0x104); |
| 11269 | /// @solidity memory-safe-assembly |
| 11270 | assembly { |
| 11271 | mstore(0x00, m0) |
| 11272 | mstore(0x20, m1) |
| 11273 | mstore(0x40, m2) |
| 11274 | mstore(0x60, m3) |
| 11275 | mstore(0x80, m4) |
| 11276 | mstore(0xa0, m5) |
| 11277 | mstore(0xc0, m6) |
| 11278 | mstore(0xe0, m7) |
| 11279 | mstore(0x100, m8) |
| 11280 | } |
| 11281 | } |
| 11282 | |
| 11283 | function log(bytes32 p0, address p1, bytes32 p2, address p3) internal pure { |
| 11284 | bytes32 m0; |
| 11285 | bytes32 m1; |
| 11286 | bytes32 m2; |
| 11287 | bytes32 m3; |
| 11288 | bytes32 m4; |
| 11289 | bytes32 m5; |
| 11290 | bytes32 m6; |
| 11291 | bytes32 m7; |
| 11292 | bytes32 m8; |
| 11293 | /// @solidity memory-safe-assembly |
| 11294 | assembly { |
| 11295 | function writeString(pos, w) { |
| 11296 | let length := 0 |
| 11297 | for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } |
| 11298 | mstore(pos, length) |
| 11299 | let shift := sub(256, shl(3, length)) |
| 11300 | mstore(add(pos, 0x20), shl(shift, shr(shift, w))) |
| 11301 | } |
| 11302 | m0 := mload(0x00) |
| 11303 | m1 := mload(0x20) |
| 11304 | m2 := mload(0x40) |
| 11305 | m3 := mload(0x60) |
| 11306 | m4 := mload(0x80) |
| 11307 | m5 := mload(0xa0) |
| 11308 | m6 := mload(0xc0) |
| 11309 | m7 := mload(0xe0) |
| 11310 | m8 := mload(0x100) |
| 11311 | // Selector of `log(string,address,string,address)`. |
| 11312 | mstore(0x00, 0xaabc9a31) |
| 11313 | mstore(0x20, 0x80) |
| 11314 | mstore(0x40, p1) |
| 11315 | mstore(0x60, 0xc0) |
| 11316 | mstore(0x80, p3) |
| 11317 | writeString(0xa0, p0) |
| 11318 | writeString(0xe0, p2) |
| 11319 | } |
| 11320 | _sendLogPayload(0x1c, 0x104); |
| 11321 | /// @solidity memory-safe-assembly |
| 11322 | assembly { |
| 11323 | mstore(0x00, m0) |
| 11324 | mstore(0x20, m1) |
| 11325 | mstore(0x40, m2) |
| 11326 | mstore(0x60, m3) |
| 11327 | mstore(0x80, m4) |
| 11328 | mstore(0xa0, m5) |
| 11329 | mstore(0xc0, m6) |
| 11330 | mstore(0xe0, m7) |
| 11331 | mstore(0x100, m8) |
| 11332 | } |
| 11333 | } |
| 11334 | |
| 11335 | function log(bytes32 p0, address p1, bytes32 p2, bool p3) internal pure { |
| 11336 | bytes32 m0; |
| 11337 | bytes32 m1; |
| 11338 | bytes32 m2; |
| 11339 | bytes32 m3; |
| 11340 | bytes32 m4; |
| 11341 | bytes32 m5; |
| 11342 | bytes32 m6; |
| 11343 | bytes32 m7; |
| 11344 | bytes32 m8; |
| 11345 | /// @solidity memory-safe-assembly |
| 11346 | assembly { |
| 11347 | function writeString(pos, w) { |
| 11348 | let length := 0 |
| 11349 | for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } |
| 11350 | mstore(pos, length) |
| 11351 | let shift := sub(256, shl(3, length)) |
| 11352 | mstore(add(pos, 0x20), shl(shift, shr(shift, w))) |
| 11353 | } |
| 11354 | m0 := mload(0x00) |
| 11355 | m1 := mload(0x20) |
| 11356 | m2 := mload(0x40) |
| 11357 | m3 := mload(0x60) |
| 11358 | m4 := mload(0x80) |
| 11359 | m5 := mload(0xa0) |
| 11360 | m6 := mload(0xc0) |
| 11361 | m7 := mload(0xe0) |
| 11362 | m8 := mload(0x100) |
| 11363 | // Selector of `log(string,address,string,bool)`. |
| 11364 | mstore(0x00, 0x5f15d28c) |
| 11365 | mstore(0x20, 0x80) |
| 11366 | mstore(0x40, p1) |
| 11367 | mstore(0x60, 0xc0) |
| 11368 | mstore(0x80, p3) |
| 11369 | writeString(0xa0, p0) |
| 11370 | writeString(0xe0, p2) |
| 11371 | } |
| 11372 | _sendLogPayload(0x1c, 0x104); |
| 11373 | /// @solidity memory-safe-assembly |
| 11374 | assembly { |
| 11375 | mstore(0x00, m0) |
| 11376 | mstore(0x20, m1) |
| 11377 | mstore(0x40, m2) |
| 11378 | mstore(0x60, m3) |
| 11379 | mstore(0x80, m4) |
| 11380 | mstore(0xa0, m5) |
| 11381 | mstore(0xc0, m6) |
| 11382 | mstore(0xe0, m7) |
| 11383 | mstore(0x100, m8) |
| 11384 | } |
| 11385 | } |
| 11386 | |
| 11387 | function log(bytes32 p0, address p1, bytes32 p2, uint256 p3) internal pure { |
| 11388 | bytes32 m0; |
| 11389 | bytes32 m1; |
| 11390 | bytes32 m2; |
| 11391 | bytes32 m3; |
| 11392 | bytes32 m4; |
| 11393 | bytes32 m5; |
| 11394 | bytes32 m6; |
| 11395 | bytes32 m7; |
| 11396 | bytes32 m8; |
| 11397 | /// @solidity memory-safe-assembly |
| 11398 | assembly { |
| 11399 | function writeString(pos, w) { |
| 11400 | let length := 0 |
| 11401 | for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } |
| 11402 | mstore(pos, length) |
| 11403 | let shift := sub(256, shl(3, length)) |
| 11404 | mstore(add(pos, 0x20), shl(shift, shr(shift, w))) |
| 11405 | } |
| 11406 | m0 := mload(0x00) |
| 11407 | m1 := mload(0x20) |
| 11408 | m2 := mload(0x40) |
| 11409 | m3 := mload(0x60) |
| 11410 | m4 := mload(0x80) |
| 11411 | m5 := mload(0xa0) |
| 11412 | m6 := mload(0xc0) |
| 11413 | m7 := mload(0xe0) |
| 11414 | m8 := mload(0x100) |
| 11415 | // Selector of `log(string,address,string,uint256)`. |
| 11416 | mstore(0x00, 0x91d1112e) |
| 11417 | mstore(0x20, 0x80) |
| 11418 | mstore(0x40, p1) |
| 11419 | mstore(0x60, 0xc0) |
| 11420 | mstore(0x80, p3) |
| 11421 | writeString(0xa0, p0) |
| 11422 | writeString(0xe0, p2) |
| 11423 | } |
| 11424 | _sendLogPayload(0x1c, 0x104); |
| 11425 | /// @solidity memory-safe-assembly |
| 11426 | assembly { |
| 11427 | mstore(0x00, m0) |
| 11428 | mstore(0x20, m1) |
| 11429 | mstore(0x40, m2) |
| 11430 | mstore(0x60, m3) |
| 11431 | mstore(0x80, m4) |
| 11432 | mstore(0xa0, m5) |
| 11433 | mstore(0xc0, m6) |
| 11434 | mstore(0xe0, m7) |
| 11435 | mstore(0x100, m8) |
| 11436 | } |
| 11437 | } |
| 11438 | |
| 11439 | function log(bytes32 p0, address p1, bytes32 p2, bytes32 p3) internal pure { |
| 11440 | bytes32 m0; |
| 11441 | bytes32 m1; |
| 11442 | bytes32 m2; |
| 11443 | bytes32 m3; |
| 11444 | bytes32 m4; |
| 11445 | bytes32 m5; |
| 11446 | bytes32 m6; |
| 11447 | bytes32 m7; |
| 11448 | bytes32 m8; |
| 11449 | bytes32 m9; |
| 11450 | bytes32 m10; |
| 11451 | /// @solidity memory-safe-assembly |
| 11452 | assembly { |
| 11453 | function writeString(pos, w) { |
| 11454 | let length := 0 |
| 11455 | for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } |
| 11456 | mstore(pos, length) |
| 11457 | let shift := sub(256, shl(3, length)) |
| 11458 | mstore(add(pos, 0x20), shl(shift, shr(shift, w))) |
| 11459 | } |
| 11460 | m0 := mload(0x00) |
| 11461 | m1 := mload(0x20) |
| 11462 | m2 := mload(0x40) |
| 11463 | m3 := mload(0x60) |
| 11464 | m4 := mload(0x80) |
| 11465 | m5 := mload(0xa0) |
| 11466 | m6 := mload(0xc0) |
| 11467 | m7 := mload(0xe0) |
| 11468 | m8 := mload(0x100) |
| 11469 | m9 := mload(0x120) |
| 11470 | m10 := mload(0x140) |
| 11471 | // Selector of `log(string,address,string,string)`. |
| 11472 | mstore(0x00, 0x245986f2) |
| 11473 | mstore(0x20, 0x80) |
| 11474 | mstore(0x40, p1) |
| 11475 | mstore(0x60, 0xc0) |
| 11476 | mstore(0x80, 0x100) |
| 11477 | writeString(0xa0, p0) |
| 11478 | writeString(0xe0, p2) |
| 11479 | writeString(0x120, p3) |
| 11480 | } |
| 11481 | _sendLogPayload(0x1c, 0x144); |
| 11482 | /// @solidity memory-safe-assembly |
| 11483 | assembly { |
| 11484 | mstore(0x00, m0) |
| 11485 | mstore(0x20, m1) |
| 11486 | mstore(0x40, m2) |
| 11487 | mstore(0x60, m3) |
| 11488 | mstore(0x80, m4) |
| 11489 | mstore(0xa0, m5) |
| 11490 | mstore(0xc0, m6) |
| 11491 | mstore(0xe0, m7) |
| 11492 | mstore(0x100, m8) |
| 11493 | mstore(0x120, m9) |
| 11494 | mstore(0x140, m10) |
| 11495 | } |
| 11496 | } |
| 11497 | |
| 11498 | function log(bytes32 p0, bool p1, address p2, address p3) internal pure { |
| 11499 | bytes32 m0; |
| 11500 | bytes32 m1; |
| 11501 | bytes32 m2; |
| 11502 | bytes32 m3; |
| 11503 | bytes32 m4; |
| 11504 | bytes32 m5; |
| 11505 | bytes32 m6; |
| 11506 | /// @solidity memory-safe-assembly |
| 11507 | assembly { |
| 11508 | function writeString(pos, w) { |
| 11509 | let length := 0 |
| 11510 | for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } |
| 11511 | mstore(pos, length) |
| 11512 | let shift := sub(256, shl(3, length)) |
| 11513 | mstore(add(pos, 0x20), shl(shift, shr(shift, w))) |
| 11514 | } |
| 11515 | m0 := mload(0x00) |
| 11516 | m1 := mload(0x20) |
| 11517 | m2 := mload(0x40) |
| 11518 | m3 := mload(0x60) |
| 11519 | m4 := mload(0x80) |
| 11520 | m5 := mload(0xa0) |
| 11521 | m6 := mload(0xc0) |
| 11522 | // Selector of `log(string,bool,address,address)`. |
| 11523 | mstore(0x00, 0x33e9dd1d) |
| 11524 | mstore(0x20, 0x80) |
| 11525 | mstore(0x40, p1) |
| 11526 | mstore(0x60, p2) |
| 11527 | mstore(0x80, p3) |
| 11528 | writeString(0xa0, p0) |
| 11529 | } |
| 11530 | _sendLogPayload(0x1c, 0xc4); |
| 11531 | /// @solidity memory-safe-assembly |
| 11532 | assembly { |
| 11533 | mstore(0x00, m0) |
| 11534 | mstore(0x20, m1) |
| 11535 | mstore(0x40, m2) |
| 11536 | mstore(0x60, m3) |
| 11537 | mstore(0x80, m4) |
| 11538 | mstore(0xa0, m5) |
| 11539 | mstore(0xc0, m6) |
| 11540 | } |
| 11541 | } |
| 11542 | |
| 11543 | function log(bytes32 p0, bool p1, address p2, bool p3) internal pure { |
| 11544 | bytes32 m0; |
| 11545 | bytes32 m1; |
| 11546 | bytes32 m2; |
| 11547 | bytes32 m3; |
| 11548 | bytes32 m4; |
| 11549 | bytes32 m5; |
| 11550 | bytes32 m6; |
| 11551 | /// @solidity memory-safe-assembly |
| 11552 | assembly { |
| 11553 | function writeString(pos, w) { |
| 11554 | let length := 0 |
| 11555 | for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } |
| 11556 | mstore(pos, length) |
| 11557 | let shift := sub(256, shl(3, length)) |
| 11558 | mstore(add(pos, 0x20), shl(shift, shr(shift, w))) |
| 11559 | } |
| 11560 | m0 := mload(0x00) |
| 11561 | m1 := mload(0x20) |
| 11562 | m2 := mload(0x40) |
| 11563 | m3 := mload(0x60) |
| 11564 | m4 := mload(0x80) |
| 11565 | m5 := mload(0xa0) |
| 11566 | m6 := mload(0xc0) |
| 11567 | // Selector of `log(string,bool,address,bool)`. |
| 11568 | mstore(0x00, 0x958c28c6) |
| 11569 | mstore(0x20, 0x80) |
| 11570 | mstore(0x40, p1) |
| 11571 | mstore(0x60, p2) |
| 11572 | mstore(0x80, p3) |
| 11573 | writeString(0xa0, p0) |
| 11574 | } |
| 11575 | _sendLogPayload(0x1c, 0xc4); |
| 11576 | /// @solidity memory-safe-assembly |
| 11577 | assembly { |
| 11578 | mstore(0x00, m0) |
| 11579 | mstore(0x20, m1) |
| 11580 | mstore(0x40, m2) |
| 11581 | mstore(0x60, m3) |
| 11582 | mstore(0x80, m4) |
| 11583 | mstore(0xa0, m5) |
| 11584 | mstore(0xc0, m6) |
| 11585 | } |
| 11586 | } |
| 11587 | |
| 11588 | function log(bytes32 p0, bool p1, address p2, uint256 p3) internal pure { |
| 11589 | bytes32 m0; |
| 11590 | bytes32 m1; |
| 11591 | bytes32 m2; |
| 11592 | bytes32 m3; |
| 11593 | bytes32 m4; |
| 11594 | bytes32 m5; |
| 11595 | bytes32 m6; |
| 11596 | /// @solidity memory-safe-assembly |
| 11597 | assembly { |
| 11598 | function writeString(pos, w) { |
| 11599 | let length := 0 |
| 11600 | for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } |
| 11601 | mstore(pos, length) |
| 11602 | let shift := sub(256, shl(3, length)) |
| 11603 | mstore(add(pos, 0x20), shl(shift, shr(shift, w))) |
| 11604 | } |
| 11605 | m0 := mload(0x00) |
| 11606 | m1 := mload(0x20) |
| 11607 | m2 := mload(0x40) |
| 11608 | m3 := mload(0x60) |
| 11609 | m4 := mload(0x80) |
| 11610 | m5 := mload(0xa0) |
| 11611 | m6 := mload(0xc0) |
| 11612 | // Selector of `log(string,bool,address,uint256)`. |
| 11613 | mstore(0x00, 0x5d08bb05) |
| 11614 | mstore(0x20, 0x80) |
| 11615 | mstore(0x40, p1) |
| 11616 | mstore(0x60, p2) |
| 11617 | mstore(0x80, p3) |
| 11618 | writeString(0xa0, p0) |
| 11619 | } |
| 11620 | _sendLogPayload(0x1c, 0xc4); |
| 11621 | /// @solidity memory-safe-assembly |
| 11622 | assembly { |
| 11623 | mstore(0x00, m0) |
| 11624 | mstore(0x20, m1) |
| 11625 | mstore(0x40, m2) |
| 11626 | mstore(0x60, m3) |
| 11627 | mstore(0x80, m4) |
| 11628 | mstore(0xa0, m5) |
| 11629 | mstore(0xc0, m6) |
| 11630 | } |
| 11631 | } |
| 11632 | |
| 11633 | function log(bytes32 p0, bool p1, address p2, bytes32 p3) internal pure { |
| 11634 | bytes32 m0; |
| 11635 | bytes32 m1; |
| 11636 | bytes32 m2; |
| 11637 | bytes32 m3; |
| 11638 | bytes32 m4; |
| 11639 | bytes32 m5; |
| 11640 | bytes32 m6; |
| 11641 | bytes32 m7; |
| 11642 | bytes32 m8; |
| 11643 | /// @solidity memory-safe-assembly |
| 11644 | assembly { |
| 11645 | function writeString(pos, w) { |
| 11646 | let length := 0 |
| 11647 | for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } |
| 11648 | mstore(pos, length) |
| 11649 | let shift := sub(256, shl(3, length)) |
| 11650 | mstore(add(pos, 0x20), shl(shift, shr(shift, w))) |
| 11651 | } |
| 11652 | m0 := mload(0x00) |
| 11653 | m1 := mload(0x20) |
| 11654 | m2 := mload(0x40) |
| 11655 | m3 := mload(0x60) |
| 11656 | m4 := mload(0x80) |
| 11657 | m5 := mload(0xa0) |
| 11658 | m6 := mload(0xc0) |
| 11659 | m7 := mload(0xe0) |
| 11660 | m8 := mload(0x100) |
| 11661 | // Selector of `log(string,bool,address,string)`. |
| 11662 | mstore(0x00, 0x2d8e33a4) |
| 11663 | mstore(0x20, 0x80) |
| 11664 | mstore(0x40, p1) |
| 11665 | mstore(0x60, p2) |
| 11666 | mstore(0x80, 0xc0) |
| 11667 | writeString(0xa0, p0) |
| 11668 | writeString(0xe0, p3) |
| 11669 | } |
| 11670 | _sendLogPayload(0x1c, 0x104); |
| 11671 | /// @solidity memory-safe-assembly |
| 11672 | assembly { |
| 11673 | mstore(0x00, m0) |
| 11674 | mstore(0x20, m1) |
| 11675 | mstore(0x40, m2) |
| 11676 | mstore(0x60, m3) |
| 11677 | mstore(0x80, m4) |
| 11678 | mstore(0xa0, m5) |
| 11679 | mstore(0xc0, m6) |
| 11680 | mstore(0xe0, m7) |
| 11681 | mstore(0x100, m8) |
| 11682 | } |
| 11683 | } |
| 11684 | |
| 11685 | function log(bytes32 p0, bool p1, bool p2, address p3) internal pure { |
| 11686 | bytes32 m0; |
| 11687 | bytes32 m1; |
| 11688 | bytes32 m2; |
| 11689 | bytes32 m3; |
| 11690 | bytes32 m4; |
| 11691 | bytes32 m5; |
| 11692 | bytes32 m6; |
| 11693 | /// @solidity memory-safe-assembly |
| 11694 | assembly { |
| 11695 | function writeString(pos, w) { |
| 11696 | let length := 0 |
| 11697 | for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } |
| 11698 | mstore(pos, length) |
| 11699 | let shift := sub(256, shl(3, length)) |
| 11700 | mstore(add(pos, 0x20), shl(shift, shr(shift, w))) |
| 11701 | } |
| 11702 | m0 := mload(0x00) |
| 11703 | m1 := mload(0x20) |
| 11704 | m2 := mload(0x40) |
| 11705 | m3 := mload(0x60) |
| 11706 | m4 := mload(0x80) |
| 11707 | m5 := mload(0xa0) |
| 11708 | m6 := mload(0xc0) |
| 11709 | // Selector of `log(string,bool,bool,address)`. |
| 11710 | mstore(0x00, 0x7190a529) |
| 11711 | mstore(0x20, 0x80) |
| 11712 | mstore(0x40, p1) |
| 11713 | mstore(0x60, p2) |
| 11714 | mstore(0x80, p3) |
| 11715 | writeString(0xa0, p0) |
| 11716 | } |
| 11717 | _sendLogPayload(0x1c, 0xc4); |
| 11718 | /// @solidity memory-safe-assembly |
| 11719 | assembly { |
| 11720 | mstore(0x00, m0) |
| 11721 | mstore(0x20, m1) |
| 11722 | mstore(0x40, m2) |
| 11723 | mstore(0x60, m3) |
| 11724 | mstore(0x80, m4) |
| 11725 | mstore(0xa0, m5) |
| 11726 | mstore(0xc0, m6) |
| 11727 | } |
| 11728 | } |
| 11729 | |
| 11730 | function log(bytes32 p0, bool p1, bool p2, bool p3) internal pure { |
| 11731 | bytes32 m0; |
| 11732 | bytes32 m1; |
| 11733 | bytes32 m2; |
| 11734 | bytes32 m3; |
| 11735 | bytes32 m4; |
| 11736 | bytes32 m5; |
| 11737 | bytes32 m6; |
| 11738 | /// @solidity memory-safe-assembly |
| 11739 | assembly { |
| 11740 | function writeString(pos, w) { |
| 11741 | let length := 0 |
| 11742 | for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } |
| 11743 | mstore(pos, length) |
| 11744 | let shift := sub(256, shl(3, length)) |
| 11745 | mstore(add(pos, 0x20), shl(shift, shr(shift, w))) |
| 11746 | } |
| 11747 | m0 := mload(0x00) |
| 11748 | m1 := mload(0x20) |
| 11749 | m2 := mload(0x40) |
| 11750 | m3 := mload(0x60) |
| 11751 | m4 := mload(0x80) |
| 11752 | m5 := mload(0xa0) |
| 11753 | m6 := mload(0xc0) |
| 11754 | // Selector of `log(string,bool,bool,bool)`. |
| 11755 | mstore(0x00, 0x895af8c5) |
| 11756 | mstore(0x20, 0x80) |
| 11757 | mstore(0x40, p1) |
| 11758 | mstore(0x60, p2) |
| 11759 | mstore(0x80, p3) |
| 11760 | writeString(0xa0, p0) |
| 11761 | } |
| 11762 | _sendLogPayload(0x1c, 0xc4); |
| 11763 | /// @solidity memory-safe-assembly |
| 11764 | assembly { |
| 11765 | mstore(0x00, m0) |
| 11766 | mstore(0x20, m1) |
| 11767 | mstore(0x40, m2) |
| 11768 | mstore(0x60, m3) |
| 11769 | mstore(0x80, m4) |
| 11770 | mstore(0xa0, m5) |
| 11771 | mstore(0xc0, m6) |
| 11772 | } |
| 11773 | } |
| 11774 | |
| 11775 | function log(bytes32 p0, bool p1, bool p2, uint256 p3) internal pure { |
| 11776 | bytes32 m0; |
| 11777 | bytes32 m1; |
| 11778 | bytes32 m2; |
| 11779 | bytes32 m3; |
| 11780 | bytes32 m4; |
| 11781 | bytes32 m5; |
| 11782 | bytes32 m6; |
| 11783 | /// @solidity memory-safe-assembly |
| 11784 | assembly { |
| 11785 | function writeString(pos, w) { |
| 11786 | let length := 0 |
| 11787 | for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } |
| 11788 | mstore(pos, length) |
| 11789 | let shift := sub(256, shl(3, length)) |
| 11790 | mstore(add(pos, 0x20), shl(shift, shr(shift, w))) |
| 11791 | } |
| 11792 | m0 := mload(0x00) |
| 11793 | m1 := mload(0x20) |
| 11794 | m2 := mload(0x40) |
| 11795 | m3 := mload(0x60) |
| 11796 | m4 := mload(0x80) |
| 11797 | m5 := mload(0xa0) |
| 11798 | m6 := mload(0xc0) |
| 11799 | // Selector of `log(string,bool,bool,uint256)`. |
| 11800 | mstore(0x00, 0x8e3f78a9) |
| 11801 | mstore(0x20, 0x80) |
| 11802 | mstore(0x40, p1) |
| 11803 | mstore(0x60, p2) |
| 11804 | mstore(0x80, p3) |
| 11805 | writeString(0xa0, p0) |
| 11806 | } |
| 11807 | _sendLogPayload(0x1c, 0xc4); |
| 11808 | /// @solidity memory-safe-assembly |
| 11809 | assembly { |
| 11810 | mstore(0x00, m0) |
| 11811 | mstore(0x20, m1) |
| 11812 | mstore(0x40, m2) |
| 11813 | mstore(0x60, m3) |
| 11814 | mstore(0x80, m4) |
| 11815 | mstore(0xa0, m5) |
| 11816 | mstore(0xc0, m6) |
| 11817 | } |
| 11818 | } |
| 11819 | |
| 11820 | function log(bytes32 p0, bool p1, bool p2, bytes32 p3) internal pure { |
| 11821 | bytes32 m0; |
| 11822 | bytes32 m1; |
| 11823 | bytes32 m2; |
| 11824 | bytes32 m3; |
| 11825 | bytes32 m4; |
| 11826 | bytes32 m5; |
| 11827 | bytes32 m6; |
| 11828 | bytes32 m7; |
| 11829 | bytes32 m8; |
| 11830 | /// @solidity memory-safe-assembly |
| 11831 | assembly { |
| 11832 | function writeString(pos, w) { |
| 11833 | let length := 0 |
| 11834 | for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } |
| 11835 | mstore(pos, length) |
| 11836 | let shift := sub(256, shl(3, length)) |
| 11837 | mstore(add(pos, 0x20), shl(shift, shr(shift, w))) |
| 11838 | } |
| 11839 | m0 := mload(0x00) |
| 11840 | m1 := mload(0x20) |
| 11841 | m2 := mload(0x40) |
| 11842 | m3 := mload(0x60) |
| 11843 | m4 := mload(0x80) |
| 11844 | m5 := mload(0xa0) |
| 11845 | m6 := mload(0xc0) |
| 11846 | m7 := mload(0xe0) |
| 11847 | m8 := mload(0x100) |
| 11848 | // Selector of `log(string,bool,bool,string)`. |
| 11849 | mstore(0x00, 0x9d22d5dd) |
| 11850 | mstore(0x20, 0x80) |
| 11851 | mstore(0x40, p1) |
| 11852 | mstore(0x60, p2) |
| 11853 | mstore(0x80, 0xc0) |
| 11854 | writeString(0xa0, p0) |
| 11855 | writeString(0xe0, p3) |
| 11856 | } |
| 11857 | _sendLogPayload(0x1c, 0x104); |
| 11858 | /// @solidity memory-safe-assembly |
| 11859 | assembly { |
| 11860 | mstore(0x00, m0) |
| 11861 | mstore(0x20, m1) |
| 11862 | mstore(0x40, m2) |
| 11863 | mstore(0x60, m3) |
| 11864 | mstore(0x80, m4) |
| 11865 | mstore(0xa0, m5) |
| 11866 | mstore(0xc0, m6) |
| 11867 | mstore(0xe0, m7) |
| 11868 | mstore(0x100, m8) |
| 11869 | } |
| 11870 | } |
| 11871 | |
| 11872 | function log(bytes32 p0, bool p1, uint256 p2, address p3) internal pure { |
| 11873 | bytes32 m0; |
| 11874 | bytes32 m1; |
| 11875 | bytes32 m2; |
| 11876 | bytes32 m3; |
| 11877 | bytes32 m4; |
| 11878 | bytes32 m5; |
| 11879 | bytes32 m6; |
| 11880 | /// @solidity memory-safe-assembly |
| 11881 | assembly { |
| 11882 | function writeString(pos, w) { |
| 11883 | let length := 0 |
| 11884 | for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } |
| 11885 | mstore(pos, length) |
| 11886 | let shift := sub(256, shl(3, length)) |
| 11887 | mstore(add(pos, 0x20), shl(shift, shr(shift, w))) |
| 11888 | } |
| 11889 | m0 := mload(0x00) |
| 11890 | m1 := mload(0x20) |
| 11891 | m2 := mload(0x40) |
| 11892 | m3 := mload(0x60) |
| 11893 | m4 := mload(0x80) |
| 11894 | m5 := mload(0xa0) |
| 11895 | m6 := mload(0xc0) |
| 11896 | // Selector of `log(string,bool,uint256,address)`. |
| 11897 | mstore(0x00, 0x935e09bf) |
| 11898 | mstore(0x20, 0x80) |
| 11899 | mstore(0x40, p1) |
| 11900 | mstore(0x60, p2) |
| 11901 | mstore(0x80, p3) |
| 11902 | writeString(0xa0, p0) |
| 11903 | } |
| 11904 | _sendLogPayload(0x1c, 0xc4); |
| 11905 | /// @solidity memory-safe-assembly |
| 11906 | assembly { |
| 11907 | mstore(0x00, m0) |
| 11908 | mstore(0x20, m1) |
| 11909 | mstore(0x40, m2) |
| 11910 | mstore(0x60, m3) |
| 11911 | mstore(0x80, m4) |
| 11912 | mstore(0xa0, m5) |
| 11913 | mstore(0xc0, m6) |
| 11914 | } |
| 11915 | } |
| 11916 | |
| 11917 | function log(bytes32 p0, bool p1, uint256 p2, bool p3) internal pure { |
| 11918 | bytes32 m0; |
| 11919 | bytes32 m1; |
| 11920 | bytes32 m2; |
| 11921 | bytes32 m3; |
| 11922 | bytes32 m4; |
| 11923 | bytes32 m5; |
| 11924 | bytes32 m6; |
| 11925 | /// @solidity memory-safe-assembly |
| 11926 | assembly { |
| 11927 | function writeString(pos, w) { |
| 11928 | let length := 0 |
| 11929 | for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } |
| 11930 | mstore(pos, length) |
| 11931 | let shift := sub(256, shl(3, length)) |
| 11932 | mstore(add(pos, 0x20), shl(shift, shr(shift, w))) |
| 11933 | } |
| 11934 | m0 := mload(0x00) |
| 11935 | m1 := mload(0x20) |
| 11936 | m2 := mload(0x40) |
| 11937 | m3 := mload(0x60) |
| 11938 | m4 := mload(0x80) |
| 11939 | m5 := mload(0xa0) |
| 11940 | m6 := mload(0xc0) |
| 11941 | // Selector of `log(string,bool,uint256,bool)`. |
| 11942 | mstore(0x00, 0x8af7cf8a) |
| 11943 | mstore(0x20, 0x80) |
| 11944 | mstore(0x40, p1) |
| 11945 | mstore(0x60, p2) |
| 11946 | mstore(0x80, p3) |
| 11947 | writeString(0xa0, p0) |
| 11948 | } |
| 11949 | _sendLogPayload(0x1c, 0xc4); |
| 11950 | /// @solidity memory-safe-assembly |
| 11951 | assembly { |
| 11952 | mstore(0x00, m0) |
| 11953 | mstore(0x20, m1) |
| 11954 | mstore(0x40, m2) |
| 11955 | mstore(0x60, m3) |
| 11956 | mstore(0x80, m4) |
| 11957 | mstore(0xa0, m5) |
| 11958 | mstore(0xc0, m6) |
| 11959 | } |
| 11960 | } |
| 11961 | |
| 11962 | function log(bytes32 p0, bool p1, uint256 p2, uint256 p3) internal pure { |
| 11963 | bytes32 m0; |
| 11964 | bytes32 m1; |
| 11965 | bytes32 m2; |
| 11966 | bytes32 m3; |
| 11967 | bytes32 m4; |
| 11968 | bytes32 m5; |
| 11969 | bytes32 m6; |
| 11970 | /// @solidity memory-safe-assembly |
| 11971 | assembly { |
| 11972 | function writeString(pos, w) { |
| 11973 | let length := 0 |
| 11974 | for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } |
| 11975 | mstore(pos, length) |
| 11976 | let shift := sub(256, shl(3, length)) |
| 11977 | mstore(add(pos, 0x20), shl(shift, shr(shift, w))) |
| 11978 | } |
| 11979 | m0 := mload(0x00) |
| 11980 | m1 := mload(0x20) |
| 11981 | m2 := mload(0x40) |
| 11982 | m3 := mload(0x60) |
| 11983 | m4 := mload(0x80) |
| 11984 | m5 := mload(0xa0) |
| 11985 | m6 := mload(0xc0) |
| 11986 | // Selector of `log(string,bool,uint256,uint256)`. |
| 11987 | mstore(0x00, 0x64b5bb67) |
| 11988 | mstore(0x20, 0x80) |
| 11989 | mstore(0x40, p1) |
| 11990 | mstore(0x60, p2) |
| 11991 | mstore(0x80, p3) |
| 11992 | writeString(0xa0, p0) |
| 11993 | } |
| 11994 | _sendLogPayload(0x1c, 0xc4); |
| 11995 | /// @solidity memory-safe-assembly |
| 11996 | assembly { |
| 11997 | mstore(0x00, m0) |
| 11998 | mstore(0x20, m1) |
| 11999 | mstore(0x40, m2) |
| 12000 | mstore(0x60, m3) |
| 12001 | mstore(0x80, m4) |
| 12002 | mstore(0xa0, m5) |
| 12003 | mstore(0xc0, m6) |
| 12004 | } |
| 12005 | } |
| 12006 | |
| 12007 | function log(bytes32 p0, bool p1, uint256 p2, bytes32 p3) internal pure { |
| 12008 | bytes32 m0; |
| 12009 | bytes32 m1; |
| 12010 | bytes32 m2; |
| 12011 | bytes32 m3; |
| 12012 | bytes32 m4; |
| 12013 | bytes32 m5; |
| 12014 | bytes32 m6; |
| 12015 | bytes32 m7; |
| 12016 | bytes32 m8; |
| 12017 | /// @solidity memory-safe-assembly |
| 12018 | assembly { |
| 12019 | function writeString(pos, w) { |
| 12020 | let length := 0 |
| 12021 | for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } |
| 12022 | mstore(pos, length) |
| 12023 | let shift := sub(256, shl(3, length)) |
| 12024 | mstore(add(pos, 0x20), shl(shift, shr(shift, w))) |
| 12025 | } |
| 12026 | m0 := mload(0x00) |
| 12027 | m1 := mload(0x20) |
| 12028 | m2 := mload(0x40) |
| 12029 | m3 := mload(0x60) |
| 12030 | m4 := mload(0x80) |
| 12031 | m5 := mload(0xa0) |
| 12032 | m6 := mload(0xc0) |
| 12033 | m7 := mload(0xe0) |
| 12034 | m8 := mload(0x100) |
| 12035 | // Selector of `log(string,bool,uint256,string)`. |
| 12036 | mstore(0x00, 0x742d6ee7) |
| 12037 | mstore(0x20, 0x80) |
| 12038 | mstore(0x40, p1) |
| 12039 | mstore(0x60, p2) |
| 12040 | mstore(0x80, 0xc0) |
| 12041 | writeString(0xa0, p0) |
| 12042 | writeString(0xe0, p3) |
| 12043 | } |
| 12044 | _sendLogPayload(0x1c, 0x104); |
| 12045 | /// @solidity memory-safe-assembly |
| 12046 | assembly { |
| 12047 | mstore(0x00, m0) |
| 12048 | mstore(0x20, m1) |
| 12049 | mstore(0x40, m2) |
| 12050 | mstore(0x60, m3) |
| 12051 | mstore(0x80, m4) |
| 12052 | mstore(0xa0, m5) |
| 12053 | mstore(0xc0, m6) |
| 12054 | mstore(0xe0, m7) |
| 12055 | mstore(0x100, m8) |
| 12056 | } |
| 12057 | } |
| 12058 | |
| 12059 | function log(bytes32 p0, bool p1, bytes32 p2, address p3) internal pure { |
| 12060 | bytes32 m0; |
| 12061 | bytes32 m1; |
| 12062 | bytes32 m2; |
| 12063 | bytes32 m3; |
| 12064 | bytes32 m4; |
| 12065 | bytes32 m5; |
| 12066 | bytes32 m6; |
| 12067 | bytes32 m7; |
| 12068 | bytes32 m8; |
| 12069 | /// @solidity memory-safe-assembly |
| 12070 | assembly { |
| 12071 | function writeString(pos, w) { |
| 12072 | let length := 0 |
| 12073 | for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } |
| 12074 | mstore(pos, length) |
| 12075 | let shift := sub(256, shl(3, length)) |
| 12076 | mstore(add(pos, 0x20), shl(shift, shr(shift, w))) |
| 12077 | } |
| 12078 | m0 := mload(0x00) |
| 12079 | m1 := mload(0x20) |
| 12080 | m2 := mload(0x40) |
| 12081 | m3 := mload(0x60) |
| 12082 | m4 := mload(0x80) |
| 12083 | m5 := mload(0xa0) |
| 12084 | m6 := mload(0xc0) |
| 12085 | m7 := mload(0xe0) |
| 12086 | m8 := mload(0x100) |
| 12087 | // Selector of `log(string,bool,string,address)`. |
| 12088 | mstore(0x00, 0xe0625b29) |
| 12089 | mstore(0x20, 0x80) |
| 12090 | mstore(0x40, p1) |
| 12091 | mstore(0x60, 0xc0) |
| 12092 | mstore(0x80, p3) |
| 12093 | writeString(0xa0, p0) |
| 12094 | writeString(0xe0, p2) |
| 12095 | } |
| 12096 | _sendLogPayload(0x1c, 0x104); |
| 12097 | /// @solidity memory-safe-assembly |
| 12098 | assembly { |
| 12099 | mstore(0x00, m0) |
| 12100 | mstore(0x20, m1) |
| 12101 | mstore(0x40, m2) |
| 12102 | mstore(0x60, m3) |
| 12103 | mstore(0x80, m4) |
| 12104 | mstore(0xa0, m5) |
| 12105 | mstore(0xc0, m6) |
| 12106 | mstore(0xe0, m7) |
| 12107 | mstore(0x100, m8) |
| 12108 | } |
| 12109 | } |
| 12110 | |
| 12111 | function log(bytes32 p0, bool p1, bytes32 p2, bool p3) internal pure { |
| 12112 | bytes32 m0; |
| 12113 | bytes32 m1; |
| 12114 | bytes32 m2; |
| 12115 | bytes32 m3; |
| 12116 | bytes32 m4; |
| 12117 | bytes32 m5; |
| 12118 | bytes32 m6; |
| 12119 | bytes32 m7; |
| 12120 | bytes32 m8; |
| 12121 | /// @solidity memory-safe-assembly |
| 12122 | assembly { |
| 12123 | function writeString(pos, w) { |
| 12124 | let length := 0 |
| 12125 | for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } |
| 12126 | mstore(pos, length) |
| 12127 | let shift := sub(256, shl(3, length)) |
| 12128 | mstore(add(pos, 0x20), shl(shift, shr(shift, w))) |
| 12129 | } |
| 12130 | m0 := mload(0x00) |
| 12131 | m1 := mload(0x20) |
| 12132 | m2 := mload(0x40) |
| 12133 | m3 := mload(0x60) |
| 12134 | m4 := mload(0x80) |
| 12135 | m5 := mload(0xa0) |
| 12136 | m6 := mload(0xc0) |
| 12137 | m7 := mload(0xe0) |
| 12138 | m8 := mload(0x100) |
| 12139 | // Selector of `log(string,bool,string,bool)`. |
| 12140 | mstore(0x00, 0x3f8a701d) |
| 12141 | mstore(0x20, 0x80) |
| 12142 | mstore(0x40, p1) |
| 12143 | mstore(0x60, 0xc0) |
| 12144 | mstore(0x80, p3) |
| 12145 | writeString(0xa0, p0) |
| 12146 | writeString(0xe0, p2) |
| 12147 | } |
| 12148 | _sendLogPayload(0x1c, 0x104); |
| 12149 | /// @solidity memory-safe-assembly |
| 12150 | assembly { |
| 12151 | mstore(0x00, m0) |
| 12152 | mstore(0x20, m1) |
| 12153 | mstore(0x40, m2) |
| 12154 | mstore(0x60, m3) |
| 12155 | mstore(0x80, m4) |
| 12156 | mstore(0xa0, m5) |
| 12157 | mstore(0xc0, m6) |
| 12158 | mstore(0xe0, m7) |
| 12159 | mstore(0x100, m8) |
| 12160 | } |
| 12161 | } |
| 12162 | |
| 12163 | function log(bytes32 p0, bool p1, bytes32 p2, uint256 p3) internal pure { |
| 12164 | bytes32 m0; |
| 12165 | bytes32 m1; |
| 12166 | bytes32 m2; |
| 12167 | bytes32 m3; |
| 12168 | bytes32 m4; |
| 12169 | bytes32 m5; |
| 12170 | bytes32 m6; |
| 12171 | bytes32 m7; |
| 12172 | bytes32 m8; |
| 12173 | /// @solidity memory-safe-assembly |
| 12174 | assembly { |
| 12175 | function writeString(pos, w) { |
| 12176 | let length := 0 |
| 12177 | for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } |
| 12178 | mstore(pos, length) |
| 12179 | let shift := sub(256, shl(3, length)) |
| 12180 | mstore(add(pos, 0x20), shl(shift, shr(shift, w))) |
| 12181 | } |
| 12182 | m0 := mload(0x00) |
| 12183 | m1 := mload(0x20) |
| 12184 | m2 := mload(0x40) |
| 12185 | m3 := mload(0x60) |
| 12186 | m4 := mload(0x80) |
| 12187 | m5 := mload(0xa0) |
| 12188 | m6 := mload(0xc0) |
| 12189 | m7 := mload(0xe0) |
| 12190 | m8 := mload(0x100) |
| 12191 | // Selector of `log(string,bool,string,uint256)`. |
| 12192 | mstore(0x00, 0x24f91465) |
| 12193 | mstore(0x20, 0x80) |
| 12194 | mstore(0x40, p1) |
| 12195 | mstore(0x60, 0xc0) |
| 12196 | mstore(0x80, p3) |
| 12197 | writeString(0xa0, p0) |
| 12198 | writeString(0xe0, p2) |
| 12199 | } |
| 12200 | _sendLogPayload(0x1c, 0x104); |
| 12201 | /// @solidity memory-safe-assembly |
| 12202 | assembly { |
| 12203 | mstore(0x00, m0) |
| 12204 | mstore(0x20, m1) |
| 12205 | mstore(0x40, m2) |
| 12206 | mstore(0x60, m3) |
| 12207 | mstore(0x80, m4) |
| 12208 | mstore(0xa0, m5) |
| 12209 | mstore(0xc0, m6) |
| 12210 | mstore(0xe0, m7) |
| 12211 | mstore(0x100, m8) |
| 12212 | } |
| 12213 | } |
| 12214 | |
| 12215 | function log(bytes32 p0, bool p1, bytes32 p2, bytes32 p3) internal pure { |
| 12216 | bytes32 m0; |
| 12217 | bytes32 m1; |
| 12218 | bytes32 m2; |
| 12219 | bytes32 m3; |
| 12220 | bytes32 m4; |
| 12221 | bytes32 m5; |
| 12222 | bytes32 m6; |
| 12223 | bytes32 m7; |
| 12224 | bytes32 m8; |
| 12225 | bytes32 m9; |
| 12226 | bytes32 m10; |
| 12227 | /// @solidity memory-safe-assembly |
| 12228 | assembly { |
| 12229 | function writeString(pos, w) { |
| 12230 | let length := 0 |
| 12231 | for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } |
| 12232 | mstore(pos, length) |
| 12233 | let shift := sub(256, shl(3, length)) |
| 12234 | mstore(add(pos, 0x20), shl(shift, shr(shift, w))) |
| 12235 | } |
| 12236 | m0 := mload(0x00) |
| 12237 | m1 := mload(0x20) |
| 12238 | m2 := mload(0x40) |
| 12239 | m3 := mload(0x60) |
| 12240 | m4 := mload(0x80) |
| 12241 | m5 := mload(0xa0) |
| 12242 | m6 := mload(0xc0) |
| 12243 | m7 := mload(0xe0) |
| 12244 | m8 := mload(0x100) |
| 12245 | m9 := mload(0x120) |
| 12246 | m10 := mload(0x140) |
| 12247 | // Selector of `log(string,bool,string,string)`. |
| 12248 | mstore(0x00, 0xa826caeb) |
| 12249 | mstore(0x20, 0x80) |
| 12250 | mstore(0x40, p1) |
| 12251 | mstore(0x60, 0xc0) |
| 12252 | mstore(0x80, 0x100) |
| 12253 | writeString(0xa0, p0) |
| 12254 | writeString(0xe0, p2) |
| 12255 | writeString(0x120, p3) |
| 12256 | } |
| 12257 | _sendLogPayload(0x1c, 0x144); |
| 12258 | /// @solidity memory-safe-assembly |
| 12259 | assembly { |
| 12260 | mstore(0x00, m0) |
| 12261 | mstore(0x20, m1) |
| 12262 | mstore(0x40, m2) |
| 12263 | mstore(0x60, m3) |
| 12264 | mstore(0x80, m4) |
| 12265 | mstore(0xa0, m5) |
| 12266 | mstore(0xc0, m6) |
| 12267 | mstore(0xe0, m7) |
| 12268 | mstore(0x100, m8) |
| 12269 | mstore(0x120, m9) |
| 12270 | mstore(0x140, m10) |
| 12271 | } |
| 12272 | } |
| 12273 | |
| 12274 | function log(bytes32 p0, uint256 p1, address p2, address p3) internal pure { |
| 12275 | bytes32 m0; |
| 12276 | bytes32 m1; |
| 12277 | bytes32 m2; |
| 12278 | bytes32 m3; |
| 12279 | bytes32 m4; |
| 12280 | bytes32 m5; |
| 12281 | bytes32 m6; |
| 12282 | /// @solidity memory-safe-assembly |
| 12283 | assembly { |
| 12284 | function writeString(pos, w) { |
| 12285 | let length := 0 |
| 12286 | for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } |
| 12287 | mstore(pos, length) |
| 12288 | let shift := sub(256, shl(3, length)) |
| 12289 | mstore(add(pos, 0x20), shl(shift, shr(shift, w))) |
| 12290 | } |
| 12291 | m0 := mload(0x00) |
| 12292 | m1 := mload(0x20) |
| 12293 | m2 := mload(0x40) |
| 12294 | m3 := mload(0x60) |
| 12295 | m4 := mload(0x80) |
| 12296 | m5 := mload(0xa0) |
| 12297 | m6 := mload(0xc0) |
| 12298 | // Selector of `log(string,uint256,address,address)`. |
| 12299 | mstore(0x00, 0x5ea2b7ae) |
| 12300 | mstore(0x20, 0x80) |
| 12301 | mstore(0x40, p1) |
| 12302 | mstore(0x60, p2) |
| 12303 | mstore(0x80, p3) |
| 12304 | writeString(0xa0, p0) |
| 12305 | } |
| 12306 | _sendLogPayload(0x1c, 0xc4); |
| 12307 | /// @solidity memory-safe-assembly |
| 12308 | assembly { |
| 12309 | mstore(0x00, m0) |
| 12310 | mstore(0x20, m1) |
| 12311 | mstore(0x40, m2) |
| 12312 | mstore(0x60, m3) |
| 12313 | mstore(0x80, m4) |
| 12314 | mstore(0xa0, m5) |
| 12315 | mstore(0xc0, m6) |
| 12316 | } |
| 12317 | } |
| 12318 | |
| 12319 | function log(bytes32 p0, uint256 p1, address p2, bool p3) internal pure { |
| 12320 | bytes32 m0; |
| 12321 | bytes32 m1; |
| 12322 | bytes32 m2; |
| 12323 | bytes32 m3; |
| 12324 | bytes32 m4; |
| 12325 | bytes32 m5; |
| 12326 | bytes32 m6; |
| 12327 | /// @solidity memory-safe-assembly |
| 12328 | assembly { |
| 12329 | function writeString(pos, w) { |
| 12330 | let length := 0 |
| 12331 | for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } |
| 12332 | mstore(pos, length) |
| 12333 | let shift := sub(256, shl(3, length)) |
| 12334 | mstore(add(pos, 0x20), shl(shift, shr(shift, w))) |
| 12335 | } |
| 12336 | m0 := mload(0x00) |
| 12337 | m1 := mload(0x20) |
| 12338 | m2 := mload(0x40) |
| 12339 | m3 := mload(0x60) |
| 12340 | m4 := mload(0x80) |
| 12341 | m5 := mload(0xa0) |
| 12342 | m6 := mload(0xc0) |
| 12343 | // Selector of `log(string,uint256,address,bool)`. |
| 12344 | mstore(0x00, 0x82112a42) |
| 12345 | mstore(0x20, 0x80) |
| 12346 | mstore(0x40, p1) |
| 12347 | mstore(0x60, p2) |
| 12348 | mstore(0x80, p3) |
| 12349 | writeString(0xa0, p0) |
| 12350 | } |
| 12351 | _sendLogPayload(0x1c, 0xc4); |
| 12352 | /// @solidity memory-safe-assembly |
| 12353 | assembly { |
| 12354 | mstore(0x00, m0) |
| 12355 | mstore(0x20, m1) |
| 12356 | mstore(0x40, m2) |
| 12357 | mstore(0x60, m3) |
| 12358 | mstore(0x80, m4) |
| 12359 | mstore(0xa0, m5) |
| 12360 | mstore(0xc0, m6) |
| 12361 | } |
| 12362 | } |
| 12363 | |
| 12364 | function log(bytes32 p0, uint256 p1, address p2, uint256 p3) internal pure { |
| 12365 | bytes32 m0; |
| 12366 | bytes32 m1; |
| 12367 | bytes32 m2; |
| 12368 | bytes32 m3; |
| 12369 | bytes32 m4; |
| 12370 | bytes32 m5; |
| 12371 | bytes32 m6; |
| 12372 | /// @solidity memory-safe-assembly |
| 12373 | assembly { |
| 12374 | function writeString(pos, w) { |
| 12375 | let length := 0 |
| 12376 | for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } |
| 12377 | mstore(pos, length) |
| 12378 | let shift := sub(256, shl(3, length)) |
| 12379 | mstore(add(pos, 0x20), shl(shift, shr(shift, w))) |
| 12380 | } |
| 12381 | m0 := mload(0x00) |
| 12382 | m1 := mload(0x20) |
| 12383 | m2 := mload(0x40) |
| 12384 | m3 := mload(0x60) |
| 12385 | m4 := mload(0x80) |
| 12386 | m5 := mload(0xa0) |
| 12387 | m6 := mload(0xc0) |
| 12388 | // Selector of `log(string,uint256,address,uint256)`. |
| 12389 | mstore(0x00, 0x4f04fdc6) |
| 12390 | mstore(0x20, 0x80) |
| 12391 | mstore(0x40, p1) |
| 12392 | mstore(0x60, p2) |
| 12393 | mstore(0x80, p3) |
| 12394 | writeString(0xa0, p0) |
| 12395 | } |
| 12396 | _sendLogPayload(0x1c, 0xc4); |
| 12397 | /// @solidity memory-safe-assembly |
| 12398 | assembly { |
| 12399 | mstore(0x00, m0) |
| 12400 | mstore(0x20, m1) |
| 12401 | mstore(0x40, m2) |
| 12402 | mstore(0x60, m3) |
| 12403 | mstore(0x80, m4) |
| 12404 | mstore(0xa0, m5) |
| 12405 | mstore(0xc0, m6) |
| 12406 | } |
| 12407 | } |
| 12408 | |
| 12409 | function log(bytes32 p0, uint256 p1, address p2, bytes32 p3) internal pure { |
| 12410 | bytes32 m0; |
| 12411 | bytes32 m1; |
| 12412 | bytes32 m2; |
| 12413 | bytes32 m3; |
| 12414 | bytes32 m4; |
| 12415 | bytes32 m5; |
| 12416 | bytes32 m6; |
| 12417 | bytes32 m7; |
| 12418 | bytes32 m8; |
| 12419 | /// @solidity memory-safe-assembly |
| 12420 | assembly { |
| 12421 | function writeString(pos, w) { |
| 12422 | let length := 0 |
| 12423 | for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } |
| 12424 | mstore(pos, length) |
| 12425 | let shift := sub(256, shl(3, length)) |
| 12426 | mstore(add(pos, 0x20), shl(shift, shr(shift, w))) |
| 12427 | } |
| 12428 | m0 := mload(0x00) |
| 12429 | m1 := mload(0x20) |
| 12430 | m2 := mload(0x40) |
| 12431 | m3 := mload(0x60) |
| 12432 | m4 := mload(0x80) |
| 12433 | m5 := mload(0xa0) |
| 12434 | m6 := mload(0xc0) |
| 12435 | m7 := mload(0xe0) |
| 12436 | m8 := mload(0x100) |
| 12437 | // Selector of `log(string,uint256,address,string)`. |
| 12438 | mstore(0x00, 0x9ffb2f93) |
| 12439 | mstore(0x20, 0x80) |
| 12440 | mstore(0x40, p1) |
| 12441 | mstore(0x60, p2) |
| 12442 | mstore(0x80, 0xc0) |
| 12443 | writeString(0xa0, p0) |
| 12444 | writeString(0xe0, p3) |
| 12445 | } |
| 12446 | _sendLogPayload(0x1c, 0x104); |
| 12447 | /// @solidity memory-safe-assembly |
| 12448 | assembly { |
| 12449 | mstore(0x00, m0) |
| 12450 | mstore(0x20, m1) |
| 12451 | mstore(0x40, m2) |
| 12452 | mstore(0x60, m3) |
| 12453 | mstore(0x80, m4) |
| 12454 | mstore(0xa0, m5) |
| 12455 | mstore(0xc0, m6) |
| 12456 | mstore(0xe0, m7) |
| 12457 | mstore(0x100, m8) |
| 12458 | } |
| 12459 | } |
| 12460 | |
| 12461 | function log(bytes32 p0, uint256 p1, bool p2, address p3) internal pure { |
| 12462 | bytes32 m0; |
| 12463 | bytes32 m1; |
| 12464 | bytes32 m2; |
| 12465 | bytes32 m3; |
| 12466 | bytes32 m4; |
| 12467 | bytes32 m5; |
| 12468 | bytes32 m6; |
| 12469 | /// @solidity memory-safe-assembly |
| 12470 | assembly { |
| 12471 | function writeString(pos, w) { |
| 12472 | let length := 0 |
| 12473 | for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } |
| 12474 | mstore(pos, length) |
| 12475 | let shift := sub(256, shl(3, length)) |
| 12476 | mstore(add(pos, 0x20), shl(shift, shr(shift, w))) |
| 12477 | } |
| 12478 | m0 := mload(0x00) |
| 12479 | m1 := mload(0x20) |
| 12480 | m2 := mload(0x40) |
| 12481 | m3 := mload(0x60) |
| 12482 | m4 := mload(0x80) |
| 12483 | m5 := mload(0xa0) |
| 12484 | m6 := mload(0xc0) |
| 12485 | // Selector of `log(string,uint256,bool,address)`. |
| 12486 | mstore(0x00, 0xe0e95b98) |
| 12487 | mstore(0x20, 0x80) |
| 12488 | mstore(0x40, p1) |
| 12489 | mstore(0x60, p2) |
| 12490 | mstore(0x80, p3) |
| 12491 | writeString(0xa0, p0) |
| 12492 | } |
| 12493 | _sendLogPayload(0x1c, 0xc4); |
| 12494 | /// @solidity memory-safe-assembly |
| 12495 | assembly { |
| 12496 | mstore(0x00, m0) |
| 12497 | mstore(0x20, m1) |
| 12498 | mstore(0x40, m2) |
| 12499 | mstore(0x60, m3) |
| 12500 | mstore(0x80, m4) |
| 12501 | mstore(0xa0, m5) |
| 12502 | mstore(0xc0, m6) |
| 12503 | } |
| 12504 | } |
| 12505 | |
| 12506 | function log(bytes32 p0, uint256 p1, bool p2, bool p3) internal pure { |
| 12507 | bytes32 m0; |
| 12508 | bytes32 m1; |
| 12509 | bytes32 m2; |
| 12510 | bytes32 m3; |
| 12511 | bytes32 m4; |
| 12512 | bytes32 m5; |
| 12513 | bytes32 m6; |
| 12514 | /// @solidity memory-safe-assembly |
| 12515 | assembly { |
| 12516 | function writeString(pos, w) { |
| 12517 | let length := 0 |
| 12518 | for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } |
| 12519 | mstore(pos, length) |
| 12520 | let shift := sub(256, shl(3, length)) |
| 12521 | mstore(add(pos, 0x20), shl(shift, shr(shift, w))) |
| 12522 | } |
| 12523 | m0 := mload(0x00) |
| 12524 | m1 := mload(0x20) |
| 12525 | m2 := mload(0x40) |
| 12526 | m3 := mload(0x60) |
| 12527 | m4 := mload(0x80) |
| 12528 | m5 := mload(0xa0) |
| 12529 | m6 := mload(0xc0) |
| 12530 | // Selector of `log(string,uint256,bool,bool)`. |
| 12531 | mstore(0x00, 0x354c36d6) |
| 12532 | mstore(0x20, 0x80) |
| 12533 | mstore(0x40, p1) |
| 12534 | mstore(0x60, p2) |
| 12535 | mstore(0x80, p3) |
| 12536 | writeString(0xa0, p0) |
| 12537 | } |
| 12538 | _sendLogPayload(0x1c, 0xc4); |
| 12539 | /// @solidity memory-safe-assembly |
| 12540 | assembly { |
| 12541 | mstore(0x00, m0) |
| 12542 | mstore(0x20, m1) |
| 12543 | mstore(0x40, m2) |
| 12544 | mstore(0x60, m3) |
| 12545 | mstore(0x80, m4) |
| 12546 | mstore(0xa0, m5) |
| 12547 | mstore(0xc0, m6) |
| 12548 | } |
| 12549 | } |
| 12550 | |
| 12551 | function log(bytes32 p0, uint256 p1, bool p2, uint256 p3) internal pure { |
| 12552 | bytes32 m0; |
| 12553 | bytes32 m1; |
| 12554 | bytes32 m2; |
| 12555 | bytes32 m3; |
| 12556 | bytes32 m4; |
| 12557 | bytes32 m5; |
| 12558 | bytes32 m6; |
| 12559 | /// @solidity memory-safe-assembly |
| 12560 | assembly { |
| 12561 | function writeString(pos, w) { |
| 12562 | let length := 0 |
| 12563 | for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } |
| 12564 | mstore(pos, length) |
| 12565 | let shift := sub(256, shl(3, length)) |
| 12566 | mstore(add(pos, 0x20), shl(shift, shr(shift, w))) |
| 12567 | } |
| 12568 | m0 := mload(0x00) |
| 12569 | m1 := mload(0x20) |
| 12570 | m2 := mload(0x40) |
| 12571 | m3 := mload(0x60) |
| 12572 | m4 := mload(0x80) |
| 12573 | m5 := mload(0xa0) |
| 12574 | m6 := mload(0xc0) |
| 12575 | // Selector of `log(string,uint256,bool,uint256)`. |
| 12576 | mstore(0x00, 0xe41b6f6f) |
| 12577 | mstore(0x20, 0x80) |
| 12578 | mstore(0x40, p1) |
| 12579 | mstore(0x60, p2) |
| 12580 | mstore(0x80, p3) |
| 12581 | writeString(0xa0, p0) |
| 12582 | } |
| 12583 | _sendLogPayload(0x1c, 0xc4); |
| 12584 | /// @solidity memory-safe-assembly |
| 12585 | assembly { |
| 12586 | mstore(0x00, m0) |
| 12587 | mstore(0x20, m1) |
| 12588 | mstore(0x40, m2) |
| 12589 | mstore(0x60, m3) |
| 12590 | mstore(0x80, m4) |
| 12591 | mstore(0xa0, m5) |
| 12592 | mstore(0xc0, m6) |
| 12593 | } |
| 12594 | } |
| 12595 | |
| 12596 | function log(bytes32 p0, uint256 p1, bool p2, bytes32 p3) internal pure { |
| 12597 | bytes32 m0; |
| 12598 | bytes32 m1; |
| 12599 | bytes32 m2; |
| 12600 | bytes32 m3; |
| 12601 | bytes32 m4; |
| 12602 | bytes32 m5; |
| 12603 | bytes32 m6; |
| 12604 | bytes32 m7; |
| 12605 | bytes32 m8; |
| 12606 | /// @solidity memory-safe-assembly |
| 12607 | assembly { |
| 12608 | function writeString(pos, w) { |
| 12609 | let length := 0 |
| 12610 | for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } |
| 12611 | mstore(pos, length) |
| 12612 | let shift := sub(256, shl(3, length)) |
| 12613 | mstore(add(pos, 0x20), shl(shift, shr(shift, w))) |
| 12614 | } |
| 12615 | m0 := mload(0x00) |
| 12616 | m1 := mload(0x20) |
| 12617 | m2 := mload(0x40) |
| 12618 | m3 := mload(0x60) |
| 12619 | m4 := mload(0x80) |
| 12620 | m5 := mload(0xa0) |
| 12621 | m6 := mload(0xc0) |
| 12622 | m7 := mload(0xe0) |
| 12623 | m8 := mload(0x100) |
| 12624 | // Selector of `log(string,uint256,bool,string)`. |
| 12625 | mstore(0x00, 0xabf73a98) |
| 12626 | mstore(0x20, 0x80) |
| 12627 | mstore(0x40, p1) |
| 12628 | mstore(0x60, p2) |
| 12629 | mstore(0x80, 0xc0) |
| 12630 | writeString(0xa0, p0) |
| 12631 | writeString(0xe0, p3) |
| 12632 | } |
| 12633 | _sendLogPayload(0x1c, 0x104); |
| 12634 | /// @solidity memory-safe-assembly |
| 12635 | assembly { |
| 12636 | mstore(0x00, m0) |
| 12637 | mstore(0x20, m1) |
| 12638 | mstore(0x40, m2) |
| 12639 | mstore(0x60, m3) |
| 12640 | mstore(0x80, m4) |
| 12641 | mstore(0xa0, m5) |
| 12642 | mstore(0xc0, m6) |
| 12643 | mstore(0xe0, m7) |
| 12644 | mstore(0x100, m8) |
| 12645 | } |
| 12646 | } |
| 12647 | |
| 12648 | function log(bytes32 p0, uint256 p1, uint256 p2, address p3) internal pure { |
| 12649 | bytes32 m0; |
| 12650 | bytes32 m1; |
| 12651 | bytes32 m2; |
| 12652 | bytes32 m3; |
| 12653 | bytes32 m4; |
| 12654 | bytes32 m5; |
| 12655 | bytes32 m6; |
| 12656 | /// @solidity memory-safe-assembly |
| 12657 | assembly { |
| 12658 | function writeString(pos, w) { |
| 12659 | let length := 0 |
| 12660 | for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } |
| 12661 | mstore(pos, length) |
| 12662 | let shift := sub(256, shl(3, length)) |
| 12663 | mstore(add(pos, 0x20), shl(shift, shr(shift, w))) |
| 12664 | } |
| 12665 | m0 := mload(0x00) |
| 12666 | m1 := mload(0x20) |
| 12667 | m2 := mload(0x40) |
| 12668 | m3 := mload(0x60) |
| 12669 | m4 := mload(0x80) |
| 12670 | m5 := mload(0xa0) |
| 12671 | m6 := mload(0xc0) |
| 12672 | // Selector of `log(string,uint256,uint256,address)`. |
| 12673 | mstore(0x00, 0xe21de278) |
| 12674 | mstore(0x20, 0x80) |
| 12675 | mstore(0x40, p1) |
| 12676 | mstore(0x60, p2) |
| 12677 | mstore(0x80, p3) |
| 12678 | writeString(0xa0, p0) |
| 12679 | } |
| 12680 | _sendLogPayload(0x1c, 0xc4); |
| 12681 | /// @solidity memory-safe-assembly |
| 12682 | assembly { |
| 12683 | mstore(0x00, m0) |
| 12684 | mstore(0x20, m1) |
| 12685 | mstore(0x40, m2) |
| 12686 | mstore(0x60, m3) |
| 12687 | mstore(0x80, m4) |
| 12688 | mstore(0xa0, m5) |
| 12689 | mstore(0xc0, m6) |
| 12690 | } |
| 12691 | } |
| 12692 | |
| 12693 | function log(bytes32 p0, uint256 p1, uint256 p2, bool p3) internal pure { |
| 12694 | bytes32 m0; |
| 12695 | bytes32 m1; |
| 12696 | bytes32 m2; |
| 12697 | bytes32 m3; |
| 12698 | bytes32 m4; |
| 12699 | bytes32 m5; |
| 12700 | bytes32 m6; |
| 12701 | /// @solidity memory-safe-assembly |
| 12702 | assembly { |
| 12703 | function writeString(pos, w) { |
| 12704 | let length := 0 |
| 12705 | for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } |
| 12706 | mstore(pos, length) |
| 12707 | let shift := sub(256, shl(3, length)) |
| 12708 | mstore(add(pos, 0x20), shl(shift, shr(shift, w))) |
| 12709 | } |
| 12710 | m0 := mload(0x00) |
| 12711 | m1 := mload(0x20) |
| 12712 | m2 := mload(0x40) |
| 12713 | m3 := mload(0x60) |
| 12714 | m4 := mload(0x80) |
| 12715 | m5 := mload(0xa0) |
| 12716 | m6 := mload(0xc0) |
| 12717 | // Selector of `log(string,uint256,uint256,bool)`. |
| 12718 | mstore(0x00, 0x7626db92) |
| 12719 | mstore(0x20, 0x80) |
| 12720 | mstore(0x40, p1) |
| 12721 | mstore(0x60, p2) |
| 12722 | mstore(0x80, p3) |
| 12723 | writeString(0xa0, p0) |
| 12724 | } |
| 12725 | _sendLogPayload(0x1c, 0xc4); |
| 12726 | /// @solidity memory-safe-assembly |
| 12727 | assembly { |
| 12728 | mstore(0x00, m0) |
| 12729 | mstore(0x20, m1) |
| 12730 | mstore(0x40, m2) |
| 12731 | mstore(0x60, m3) |
| 12732 | mstore(0x80, m4) |
| 12733 | mstore(0xa0, m5) |
| 12734 | mstore(0xc0, m6) |
| 12735 | } |
| 12736 | } |
| 12737 | |
| 12738 | function log(bytes32 p0, uint256 p1, uint256 p2, uint256 p3) internal pure { |
| 12739 | bytes32 m0; |
| 12740 | bytes32 m1; |
| 12741 | bytes32 m2; |
| 12742 | bytes32 m3; |
| 12743 | bytes32 m4; |
| 12744 | bytes32 m5; |
| 12745 | bytes32 m6; |
| 12746 | /// @solidity memory-safe-assembly |
| 12747 | assembly { |
| 12748 | function writeString(pos, w) { |
| 12749 | let length := 0 |
| 12750 | for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } |
| 12751 | mstore(pos, length) |
| 12752 | let shift := sub(256, shl(3, length)) |
| 12753 | mstore(add(pos, 0x20), shl(shift, shr(shift, w))) |
| 12754 | } |
| 12755 | m0 := mload(0x00) |
| 12756 | m1 := mload(0x20) |
| 12757 | m2 := mload(0x40) |
| 12758 | m3 := mload(0x60) |
| 12759 | m4 := mload(0x80) |
| 12760 | m5 := mload(0xa0) |
| 12761 | m6 := mload(0xc0) |
| 12762 | // Selector of `log(string,uint256,uint256,uint256)`. |
| 12763 | mstore(0x00, 0xa7a87853) |
| 12764 | mstore(0x20, 0x80) |
| 12765 | mstore(0x40, p1) |
| 12766 | mstore(0x60, p2) |
| 12767 | mstore(0x80, p3) |
| 12768 | writeString(0xa0, p0) |
| 12769 | } |
| 12770 | _sendLogPayload(0x1c, 0xc4); |
| 12771 | /// @solidity memory-safe-assembly |
| 12772 | assembly { |
| 12773 | mstore(0x00, m0) |
| 12774 | mstore(0x20, m1) |
| 12775 | mstore(0x40, m2) |
| 12776 | mstore(0x60, m3) |
| 12777 | mstore(0x80, m4) |
| 12778 | mstore(0xa0, m5) |
| 12779 | mstore(0xc0, m6) |
| 12780 | } |
| 12781 | } |
| 12782 | |
| 12783 | function log(bytes32 p0, uint256 p1, uint256 p2, bytes32 p3) internal pure { |
| 12784 | bytes32 m0; |
| 12785 | bytes32 m1; |
| 12786 | bytes32 m2; |
| 12787 | bytes32 m3; |
| 12788 | bytes32 m4; |
| 12789 | bytes32 m5; |
| 12790 | bytes32 m6; |
| 12791 | bytes32 m7; |
| 12792 | bytes32 m8; |
| 12793 | /// @solidity memory-safe-assembly |
| 12794 | assembly { |
| 12795 | function writeString(pos, w) { |
| 12796 | let length := 0 |
| 12797 | for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } |
| 12798 | mstore(pos, length) |
| 12799 | let shift := sub(256, shl(3, length)) |
| 12800 | mstore(add(pos, 0x20), shl(shift, shr(shift, w))) |
| 12801 | } |
| 12802 | m0 := mload(0x00) |
| 12803 | m1 := mload(0x20) |
| 12804 | m2 := mload(0x40) |
| 12805 | m3 := mload(0x60) |
| 12806 | m4 := mload(0x80) |
| 12807 | m5 := mload(0xa0) |
| 12808 | m6 := mload(0xc0) |
| 12809 | m7 := mload(0xe0) |
| 12810 | m8 := mload(0x100) |
| 12811 | // Selector of `log(string,uint256,uint256,string)`. |
| 12812 | mstore(0x00, 0x854b3496) |
| 12813 | mstore(0x20, 0x80) |
| 12814 | mstore(0x40, p1) |
| 12815 | mstore(0x60, p2) |
| 12816 | mstore(0x80, 0xc0) |
| 12817 | writeString(0xa0, p0) |
| 12818 | writeString(0xe0, p3) |
| 12819 | } |
| 12820 | _sendLogPayload(0x1c, 0x104); |
| 12821 | /// @solidity memory-safe-assembly |
| 12822 | assembly { |
| 12823 | mstore(0x00, m0) |
| 12824 | mstore(0x20, m1) |
| 12825 | mstore(0x40, m2) |
| 12826 | mstore(0x60, m3) |
| 12827 | mstore(0x80, m4) |
| 12828 | mstore(0xa0, m5) |
| 12829 | mstore(0xc0, m6) |
| 12830 | mstore(0xe0, m7) |
| 12831 | mstore(0x100, m8) |
| 12832 | } |
| 12833 | } |
| 12834 | |
| 12835 | function log(bytes32 p0, uint256 p1, bytes32 p2, address p3) internal pure { |
| 12836 | bytes32 m0; |
| 12837 | bytes32 m1; |
| 12838 | bytes32 m2; |
| 12839 | bytes32 m3; |
| 12840 | bytes32 m4; |
| 12841 | bytes32 m5; |
| 12842 | bytes32 m6; |
| 12843 | bytes32 m7; |
| 12844 | bytes32 m8; |
| 12845 | /// @solidity memory-safe-assembly |
| 12846 | assembly { |
| 12847 | function writeString(pos, w) { |
| 12848 | let length := 0 |
| 12849 | for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } |
| 12850 | mstore(pos, length) |
| 12851 | let shift := sub(256, shl(3, length)) |
| 12852 | mstore(add(pos, 0x20), shl(shift, shr(shift, w))) |
| 12853 | } |
| 12854 | m0 := mload(0x00) |
| 12855 | m1 := mload(0x20) |
| 12856 | m2 := mload(0x40) |
| 12857 | m3 := mload(0x60) |
| 12858 | m4 := mload(0x80) |
| 12859 | m5 := mload(0xa0) |
| 12860 | m6 := mload(0xc0) |
| 12861 | m7 := mload(0xe0) |
| 12862 | m8 := mload(0x100) |
| 12863 | // Selector of `log(string,uint256,string,address)`. |
| 12864 | mstore(0x00, 0x7c4632a4) |
| 12865 | mstore(0x20, 0x80) |
| 12866 | mstore(0x40, p1) |
| 12867 | mstore(0x60, 0xc0) |
| 12868 | mstore(0x80, p3) |
| 12869 | writeString(0xa0, p0) |
| 12870 | writeString(0xe0, p2) |
| 12871 | } |
| 12872 | _sendLogPayload(0x1c, 0x104); |
| 12873 | /// @solidity memory-safe-assembly |
| 12874 | assembly { |
| 12875 | mstore(0x00, m0) |
| 12876 | mstore(0x20, m1) |
| 12877 | mstore(0x40, m2) |
| 12878 | mstore(0x60, m3) |
| 12879 | mstore(0x80, m4) |
| 12880 | mstore(0xa0, m5) |
| 12881 | mstore(0xc0, m6) |
| 12882 | mstore(0xe0, m7) |
| 12883 | mstore(0x100, m8) |
| 12884 | } |
| 12885 | } |
| 12886 | |
| 12887 | function log(bytes32 p0, uint256 p1, bytes32 p2, bool p3) internal pure { |
| 12888 | bytes32 m0; |
| 12889 | bytes32 m1; |
| 12890 | bytes32 m2; |
| 12891 | bytes32 m3; |
| 12892 | bytes32 m4; |
| 12893 | bytes32 m5; |
| 12894 | bytes32 m6; |
| 12895 | bytes32 m7; |
| 12896 | bytes32 m8; |
| 12897 | /// @solidity memory-safe-assembly |
| 12898 | assembly { |
| 12899 | function writeString(pos, w) { |
| 12900 | let length := 0 |
| 12901 | for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } |
| 12902 | mstore(pos, length) |
| 12903 | let shift := sub(256, shl(3, length)) |
| 12904 | mstore(add(pos, 0x20), shl(shift, shr(shift, w))) |
| 12905 | } |
| 12906 | m0 := mload(0x00) |
| 12907 | m1 := mload(0x20) |
| 12908 | m2 := mload(0x40) |
| 12909 | m3 := mload(0x60) |
| 12910 | m4 := mload(0x80) |
| 12911 | m5 := mload(0xa0) |
| 12912 | m6 := mload(0xc0) |
| 12913 | m7 := mload(0xe0) |
| 12914 | m8 := mload(0x100) |
| 12915 | // Selector of `log(string,uint256,string,bool)`. |
| 12916 | mstore(0x00, 0x7d24491d) |
| 12917 | mstore(0x20, 0x80) |
| 12918 | mstore(0x40, p1) |
| 12919 | mstore(0x60, 0xc0) |
| 12920 | mstore(0x80, p3) |
| 12921 | writeString(0xa0, p0) |
| 12922 | writeString(0xe0, p2) |
| 12923 | } |
| 12924 | _sendLogPayload(0x1c, 0x104); |
| 12925 | /// @solidity memory-safe-assembly |
| 12926 | assembly { |
| 12927 | mstore(0x00, m0) |
| 12928 | mstore(0x20, m1) |
| 12929 | mstore(0x40, m2) |
| 12930 | mstore(0x60, m3) |
| 12931 | mstore(0x80, m4) |
| 12932 | mstore(0xa0, m5) |
| 12933 | mstore(0xc0, m6) |
| 12934 | mstore(0xe0, m7) |
| 12935 | mstore(0x100, m8) |
| 12936 | } |
| 12937 | } |
| 12938 | |
| 12939 | function log(bytes32 p0, uint256 p1, bytes32 p2, uint256 p3) internal pure { |
| 12940 | bytes32 m0; |
| 12941 | bytes32 m1; |
| 12942 | bytes32 m2; |
| 12943 | bytes32 m3; |
| 12944 | bytes32 m4; |
| 12945 | bytes32 m5; |
| 12946 | bytes32 m6; |
| 12947 | bytes32 m7; |
| 12948 | bytes32 m8; |
| 12949 | /// @solidity memory-safe-assembly |
| 12950 | assembly { |
| 12951 | function writeString(pos, w) { |
| 12952 | let length := 0 |
| 12953 | for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } |
| 12954 | mstore(pos, length) |
| 12955 | let shift := sub(256, shl(3, length)) |
| 12956 | mstore(add(pos, 0x20), shl(shift, shr(shift, w))) |
| 12957 | } |
| 12958 | m0 := mload(0x00) |
| 12959 | m1 := mload(0x20) |
| 12960 | m2 := mload(0x40) |
| 12961 | m3 := mload(0x60) |
| 12962 | m4 := mload(0x80) |
| 12963 | m5 := mload(0xa0) |
| 12964 | m6 := mload(0xc0) |
| 12965 | m7 := mload(0xe0) |
| 12966 | m8 := mload(0x100) |
| 12967 | // Selector of `log(string,uint256,string,uint256)`. |
| 12968 | mstore(0x00, 0xc67ea9d1) |
| 12969 | mstore(0x20, 0x80) |
| 12970 | mstore(0x40, p1) |
| 12971 | mstore(0x60, 0xc0) |
| 12972 | mstore(0x80, p3) |
| 12973 | writeString(0xa0, p0) |
| 12974 | writeString(0xe0, p2) |
| 12975 | } |
| 12976 | _sendLogPayload(0x1c, 0x104); |
| 12977 | /// @solidity memory-safe-assembly |
| 12978 | assembly { |
| 12979 | mstore(0x00, m0) |
| 12980 | mstore(0x20, m1) |
| 12981 | mstore(0x40, m2) |
| 12982 | mstore(0x60, m3) |
| 12983 | mstore(0x80, m4) |
| 12984 | mstore(0xa0, m5) |
| 12985 | mstore(0xc0, m6) |
| 12986 | mstore(0xe0, m7) |
| 12987 | mstore(0x100, m8) |
| 12988 | } |
| 12989 | } |
| 12990 | |
| 12991 | function log(bytes32 p0, uint256 p1, bytes32 p2, bytes32 p3) internal pure { |
| 12992 | bytes32 m0; |
| 12993 | bytes32 m1; |
| 12994 | bytes32 m2; |
| 12995 | bytes32 m3; |
| 12996 | bytes32 m4; |
| 12997 | bytes32 m5; |
| 12998 | bytes32 m6; |
| 12999 | bytes32 m7; |
| 13000 | bytes32 m8; |
| 13001 | bytes32 m9; |
| 13002 | bytes32 m10; |
| 13003 | /// @solidity memory-safe-assembly |
| 13004 | assembly { |
| 13005 | function writeString(pos, w) { |
| 13006 | let length := 0 |
| 13007 | for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } |
| 13008 | mstore(pos, length) |
| 13009 | let shift := sub(256, shl(3, length)) |
| 13010 | mstore(add(pos, 0x20), shl(shift, shr(shift, w))) |
| 13011 | } |
| 13012 | m0 := mload(0x00) |
| 13013 | m1 := mload(0x20) |
| 13014 | m2 := mload(0x40) |
| 13015 | m3 := mload(0x60) |
| 13016 | m4 := mload(0x80) |
| 13017 | m5 := mload(0xa0) |
| 13018 | m6 := mload(0xc0) |
| 13019 | m7 := mload(0xe0) |
| 13020 | m8 := mload(0x100) |
| 13021 | m9 := mload(0x120) |
| 13022 | m10 := mload(0x140) |
| 13023 | // Selector of `log(string,uint256,string,string)`. |
| 13024 | mstore(0x00, 0x5ab84e1f) |
| 13025 | mstore(0x20, 0x80) |
| 13026 | mstore(0x40, p1) |
| 13027 | mstore(0x60, 0xc0) |
| 13028 | mstore(0x80, 0x100) |
| 13029 | writeString(0xa0, p0) |
| 13030 | writeString(0xe0, p2) |
| 13031 | writeString(0x120, p3) |
| 13032 | } |
| 13033 | _sendLogPayload(0x1c, 0x144); |
| 13034 | /// @solidity memory-safe-assembly |
| 13035 | assembly { |
| 13036 | mstore(0x00, m0) |
| 13037 | mstore(0x20, m1) |
| 13038 | mstore(0x40, m2) |
| 13039 | mstore(0x60, m3) |
| 13040 | mstore(0x80, m4) |
| 13041 | mstore(0xa0, m5) |
| 13042 | mstore(0xc0, m6) |
| 13043 | mstore(0xe0, m7) |
| 13044 | mstore(0x100, m8) |
| 13045 | mstore(0x120, m9) |
| 13046 | mstore(0x140, m10) |
| 13047 | } |
| 13048 | } |
| 13049 | |
| 13050 | function log(bytes32 p0, bytes32 p1, address p2, address p3) internal pure { |
| 13051 | bytes32 m0; |
| 13052 | bytes32 m1; |
| 13053 | bytes32 m2; |
| 13054 | bytes32 m3; |
| 13055 | bytes32 m4; |
| 13056 | bytes32 m5; |
| 13057 | bytes32 m6; |
| 13058 | bytes32 m7; |
| 13059 | bytes32 m8; |
| 13060 | /// @solidity memory-safe-assembly |
| 13061 | assembly { |
| 13062 | function writeString(pos, w) { |
| 13063 | let length := 0 |
| 13064 | for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } |
| 13065 | mstore(pos, length) |
| 13066 | let shift := sub(256, shl(3, length)) |
| 13067 | mstore(add(pos, 0x20), shl(shift, shr(shift, w))) |
| 13068 | } |
| 13069 | m0 := mload(0x00) |
| 13070 | m1 := mload(0x20) |
| 13071 | m2 := mload(0x40) |
| 13072 | m3 := mload(0x60) |
| 13073 | m4 := mload(0x80) |
| 13074 | m5 := mload(0xa0) |
| 13075 | m6 := mload(0xc0) |
| 13076 | m7 := mload(0xe0) |
| 13077 | m8 := mload(0x100) |
| 13078 | // Selector of `log(string,string,address,address)`. |
| 13079 | mstore(0x00, 0x439c7bef) |
| 13080 | mstore(0x20, 0x80) |
| 13081 | mstore(0x40, 0xc0) |
| 13082 | mstore(0x60, p2) |
| 13083 | mstore(0x80, p3) |
| 13084 | writeString(0xa0, p0) |
| 13085 | writeString(0xe0, p1) |
| 13086 | } |
| 13087 | _sendLogPayload(0x1c, 0x104); |
| 13088 | /// @solidity memory-safe-assembly |
| 13089 | assembly { |
| 13090 | mstore(0x00, m0) |
| 13091 | mstore(0x20, m1) |
| 13092 | mstore(0x40, m2) |
| 13093 | mstore(0x60, m3) |
| 13094 | mstore(0x80, m4) |
| 13095 | mstore(0xa0, m5) |
| 13096 | mstore(0xc0, m6) |
| 13097 | mstore(0xe0, m7) |
| 13098 | mstore(0x100, m8) |
| 13099 | } |
| 13100 | } |
| 13101 | |
| 13102 | function log(bytes32 p0, bytes32 p1, address p2, bool p3) internal pure { |
| 13103 | bytes32 m0; |
| 13104 | bytes32 m1; |
| 13105 | bytes32 m2; |
| 13106 | bytes32 m3; |
| 13107 | bytes32 m4; |
| 13108 | bytes32 m5; |
| 13109 | bytes32 m6; |
| 13110 | bytes32 m7; |
| 13111 | bytes32 m8; |
| 13112 | /// @solidity memory-safe-assembly |
| 13113 | assembly { |
| 13114 | function writeString(pos, w) { |
| 13115 | let length := 0 |
| 13116 | for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } |
| 13117 | mstore(pos, length) |
| 13118 | let shift := sub(256, shl(3, length)) |
| 13119 | mstore(add(pos, 0x20), shl(shift, shr(shift, w))) |
| 13120 | } |
| 13121 | m0 := mload(0x00) |
| 13122 | m1 := mload(0x20) |
| 13123 | m2 := mload(0x40) |
| 13124 | m3 := mload(0x60) |
| 13125 | m4 := mload(0x80) |
| 13126 | m5 := mload(0xa0) |
| 13127 | m6 := mload(0xc0) |
| 13128 | m7 := mload(0xe0) |
| 13129 | m8 := mload(0x100) |
| 13130 | // Selector of `log(string,string,address,bool)`. |
| 13131 | mstore(0x00, 0x5ccd4e37) |
| 13132 | mstore(0x20, 0x80) |
| 13133 | mstore(0x40, 0xc0) |
| 13134 | mstore(0x60, p2) |
| 13135 | mstore(0x80, p3) |
| 13136 | writeString(0xa0, p0) |
| 13137 | writeString(0xe0, p1) |
| 13138 | } |
| 13139 | _sendLogPayload(0x1c, 0x104); |
| 13140 | /// @solidity memory-safe-assembly |
| 13141 | assembly { |
| 13142 | mstore(0x00, m0) |
| 13143 | mstore(0x20, m1) |
| 13144 | mstore(0x40, m2) |
| 13145 | mstore(0x60, m3) |
| 13146 | mstore(0x80, m4) |
| 13147 | mstore(0xa0, m5) |
| 13148 | mstore(0xc0, m6) |
| 13149 | mstore(0xe0, m7) |
| 13150 | mstore(0x100, m8) |
| 13151 | } |
| 13152 | } |
| 13153 | |
| 13154 | function log(bytes32 p0, bytes32 p1, address p2, uint256 p3) internal pure { |
| 13155 | bytes32 m0; |
| 13156 | bytes32 m1; |
| 13157 | bytes32 m2; |
| 13158 | bytes32 m3; |
| 13159 | bytes32 m4; |
| 13160 | bytes32 m5; |
| 13161 | bytes32 m6; |
| 13162 | bytes32 m7; |
| 13163 | bytes32 m8; |
| 13164 | /// @solidity memory-safe-assembly |
| 13165 | assembly { |
| 13166 | function writeString(pos, w) { |
| 13167 | let length := 0 |
| 13168 | for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } |
| 13169 | mstore(pos, length) |
| 13170 | let shift := sub(256, shl(3, length)) |
| 13171 | mstore(add(pos, 0x20), shl(shift, shr(shift, w))) |
| 13172 | } |
| 13173 | m0 := mload(0x00) |
| 13174 | m1 := mload(0x20) |
| 13175 | m2 := mload(0x40) |
| 13176 | m3 := mload(0x60) |
| 13177 | m4 := mload(0x80) |
| 13178 | m5 := mload(0xa0) |
| 13179 | m6 := mload(0xc0) |
| 13180 | m7 := mload(0xe0) |
| 13181 | m8 := mload(0x100) |
| 13182 | // Selector of `log(string,string,address,uint256)`. |
| 13183 | mstore(0x00, 0x7cc3c607) |
| 13184 | mstore(0x20, 0x80) |
| 13185 | mstore(0x40, 0xc0) |
| 13186 | mstore(0x60, p2) |
| 13187 | mstore(0x80, p3) |
| 13188 | writeString(0xa0, p0) |
| 13189 | writeString(0xe0, p1) |
| 13190 | } |
| 13191 | _sendLogPayload(0x1c, 0x104); |
| 13192 | /// @solidity memory-safe-assembly |
| 13193 | assembly { |
| 13194 | mstore(0x00, m0) |
| 13195 | mstore(0x20, m1) |
| 13196 | mstore(0x40, m2) |
| 13197 | mstore(0x60, m3) |
| 13198 | mstore(0x80, m4) |
| 13199 | mstore(0xa0, m5) |
| 13200 | mstore(0xc0, m6) |
| 13201 | mstore(0xe0, m7) |
| 13202 | mstore(0x100, m8) |
| 13203 | } |
| 13204 | } |
| 13205 | |
| 13206 | function log(bytes32 p0, bytes32 p1, address p2, bytes32 p3) internal pure { |
| 13207 | bytes32 m0; |
| 13208 | bytes32 m1; |
| 13209 | bytes32 m2; |
| 13210 | bytes32 m3; |
| 13211 | bytes32 m4; |
| 13212 | bytes32 m5; |
| 13213 | bytes32 m6; |
| 13214 | bytes32 m7; |
| 13215 | bytes32 m8; |
| 13216 | bytes32 m9; |
| 13217 | bytes32 m10; |
| 13218 | /// @solidity memory-safe-assembly |
| 13219 | assembly { |
| 13220 | function writeString(pos, w) { |
| 13221 | let length := 0 |
| 13222 | for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } |
| 13223 | mstore(pos, length) |
| 13224 | let shift := sub(256, shl(3, length)) |
| 13225 | mstore(add(pos, 0x20), shl(shift, shr(shift, w))) |
| 13226 | } |
| 13227 | m0 := mload(0x00) |
| 13228 | m1 := mload(0x20) |
| 13229 | m2 := mload(0x40) |
| 13230 | m3 := mload(0x60) |
| 13231 | m4 := mload(0x80) |
| 13232 | m5 := mload(0xa0) |
| 13233 | m6 := mload(0xc0) |
| 13234 | m7 := mload(0xe0) |
| 13235 | m8 := mload(0x100) |
| 13236 | m9 := mload(0x120) |
| 13237 | m10 := mload(0x140) |
| 13238 | // Selector of `log(string,string,address,string)`. |
| 13239 | mstore(0x00, 0xeb1bff80) |
| 13240 | mstore(0x20, 0x80) |
| 13241 | mstore(0x40, 0xc0) |
| 13242 | mstore(0x60, p2) |
| 13243 | mstore(0x80, 0x100) |
| 13244 | writeString(0xa0, p0) |
| 13245 | writeString(0xe0, p1) |
| 13246 | writeString(0x120, p3) |
| 13247 | } |
| 13248 | _sendLogPayload(0x1c, 0x144); |
| 13249 | /// @solidity memory-safe-assembly |
| 13250 | assembly { |
| 13251 | mstore(0x00, m0) |
| 13252 | mstore(0x20, m1) |
| 13253 | mstore(0x40, m2) |
| 13254 | mstore(0x60, m3) |
| 13255 | mstore(0x80, m4) |
| 13256 | mstore(0xa0, m5) |
| 13257 | mstore(0xc0, m6) |
| 13258 | mstore(0xe0, m7) |
| 13259 | mstore(0x100, m8) |
| 13260 | mstore(0x120, m9) |
| 13261 | mstore(0x140, m10) |
| 13262 | } |
| 13263 | } |
| 13264 | |
| 13265 | function log(bytes32 p0, bytes32 p1, bool p2, address p3) internal pure { |
| 13266 | bytes32 m0; |
| 13267 | bytes32 m1; |
| 13268 | bytes32 m2; |
| 13269 | bytes32 m3; |
| 13270 | bytes32 m4; |
| 13271 | bytes32 m5; |
| 13272 | bytes32 m6; |
| 13273 | bytes32 m7; |
| 13274 | bytes32 m8; |
| 13275 | /// @solidity memory-safe-assembly |
| 13276 | assembly { |
| 13277 | function writeString(pos, w) { |
| 13278 | let length := 0 |
| 13279 | for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } |
| 13280 | mstore(pos, length) |
| 13281 | let shift := sub(256, shl(3, length)) |
| 13282 | mstore(add(pos, 0x20), shl(shift, shr(shift, w))) |
| 13283 | } |
| 13284 | m0 := mload(0x00) |
| 13285 | m1 := mload(0x20) |
| 13286 | m2 := mload(0x40) |
| 13287 | m3 := mload(0x60) |
| 13288 | m4 := mload(0x80) |
| 13289 | m5 := mload(0xa0) |
| 13290 | m6 := mload(0xc0) |
| 13291 | m7 := mload(0xe0) |
| 13292 | m8 := mload(0x100) |
| 13293 | // Selector of `log(string,string,bool,address)`. |
| 13294 | mstore(0x00, 0xc371c7db) |
| 13295 | mstore(0x20, 0x80) |
| 13296 | mstore(0x40, 0xc0) |
| 13297 | mstore(0x60, p2) |
| 13298 | mstore(0x80, p3) |
| 13299 | writeString(0xa0, p0) |
| 13300 | writeString(0xe0, p1) |
| 13301 | } |
| 13302 | _sendLogPayload(0x1c, 0x104); |
| 13303 | /// @solidity memory-safe-assembly |
| 13304 | assembly { |
| 13305 | mstore(0x00, m0) |
| 13306 | mstore(0x20, m1) |
| 13307 | mstore(0x40, m2) |
| 13308 | mstore(0x60, m3) |
| 13309 | mstore(0x80, m4) |
| 13310 | mstore(0xa0, m5) |
| 13311 | mstore(0xc0, m6) |
| 13312 | mstore(0xe0, m7) |
| 13313 | mstore(0x100, m8) |
| 13314 | } |
| 13315 | } |
| 13316 | |
| 13317 | function log(bytes32 p0, bytes32 p1, bool p2, bool p3) internal pure { |
| 13318 | bytes32 m0; |
| 13319 | bytes32 m1; |
| 13320 | bytes32 m2; |
| 13321 | bytes32 m3; |
| 13322 | bytes32 m4; |
| 13323 | bytes32 m5; |
| 13324 | bytes32 m6; |
| 13325 | bytes32 m7; |
| 13326 | bytes32 m8; |
| 13327 | /// @solidity memory-safe-assembly |
| 13328 | assembly { |
| 13329 | function writeString(pos, w) { |
| 13330 | let length := 0 |
| 13331 | for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } |
| 13332 | mstore(pos, length) |
| 13333 | let shift := sub(256, shl(3, length)) |
| 13334 | mstore(add(pos, 0x20), shl(shift, shr(shift, w))) |
| 13335 | } |
| 13336 | m0 := mload(0x00) |
| 13337 | m1 := mload(0x20) |
| 13338 | m2 := mload(0x40) |
| 13339 | m3 := mload(0x60) |
| 13340 | m4 := mload(0x80) |
| 13341 | m5 := mload(0xa0) |
| 13342 | m6 := mload(0xc0) |
| 13343 | m7 := mload(0xe0) |
| 13344 | m8 := mload(0x100) |
| 13345 | // Selector of `log(string,string,bool,bool)`. |
| 13346 | mstore(0x00, 0x40785869) |
| 13347 | mstore(0x20, 0x80) |
| 13348 | mstore(0x40, 0xc0) |
| 13349 | mstore(0x60, p2) |
| 13350 | mstore(0x80, p3) |
| 13351 | writeString(0xa0, p0) |
| 13352 | writeString(0xe0, p1) |
| 13353 | } |
| 13354 | _sendLogPayload(0x1c, 0x104); |
| 13355 | /// @solidity memory-safe-assembly |
| 13356 | assembly { |
| 13357 | mstore(0x00, m0) |
| 13358 | mstore(0x20, m1) |
| 13359 | mstore(0x40, m2) |
| 13360 | mstore(0x60, m3) |
| 13361 | mstore(0x80, m4) |
| 13362 | mstore(0xa0, m5) |
| 13363 | mstore(0xc0, m6) |
| 13364 | mstore(0xe0, m7) |
| 13365 | mstore(0x100, m8) |
| 13366 | } |
| 13367 | } |
| 13368 | |
| 13369 | function log(bytes32 p0, bytes32 p1, bool p2, uint256 p3) internal pure { |
| 13370 | bytes32 m0; |
| 13371 | bytes32 m1; |
| 13372 | bytes32 m2; |
| 13373 | bytes32 m3; |
| 13374 | bytes32 m4; |
| 13375 | bytes32 m5; |
| 13376 | bytes32 m6; |
| 13377 | bytes32 m7; |
| 13378 | bytes32 m8; |
| 13379 | /// @solidity memory-safe-assembly |
| 13380 | assembly { |
| 13381 | function writeString(pos, w) { |
| 13382 | let length := 0 |
| 13383 | for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } |
| 13384 | mstore(pos, length) |
| 13385 | let shift := sub(256, shl(3, length)) |
| 13386 | mstore(add(pos, 0x20), shl(shift, shr(shift, w))) |
| 13387 | } |
| 13388 | m0 := mload(0x00) |
| 13389 | m1 := mload(0x20) |
| 13390 | m2 := mload(0x40) |
| 13391 | m3 := mload(0x60) |
| 13392 | m4 := mload(0x80) |
| 13393 | m5 := mload(0xa0) |
| 13394 | m6 := mload(0xc0) |
| 13395 | m7 := mload(0xe0) |
| 13396 | m8 := mload(0x100) |
| 13397 | // Selector of `log(string,string,bool,uint256)`. |
| 13398 | mstore(0x00, 0xd6aefad2) |
| 13399 | mstore(0x20, 0x80) |
| 13400 | mstore(0x40, 0xc0) |
| 13401 | mstore(0x60, p2) |
| 13402 | mstore(0x80, p3) |
| 13403 | writeString(0xa0, p0) |
| 13404 | writeString(0xe0, p1) |
| 13405 | } |
| 13406 | _sendLogPayload(0x1c, 0x104); |
| 13407 | /// @solidity memory-safe-assembly |
| 13408 | assembly { |
| 13409 | mstore(0x00, m0) |
| 13410 | mstore(0x20, m1) |
| 13411 | mstore(0x40, m2) |
| 13412 | mstore(0x60, m3) |
| 13413 | mstore(0x80, m4) |
| 13414 | mstore(0xa0, m5) |
| 13415 | mstore(0xc0, m6) |
| 13416 | mstore(0xe0, m7) |
| 13417 | mstore(0x100, m8) |
| 13418 | } |
| 13419 | } |
| 13420 | |
| 13421 | function log(bytes32 p0, bytes32 p1, bool p2, bytes32 p3) internal pure { |
| 13422 | bytes32 m0; |
| 13423 | bytes32 m1; |
| 13424 | bytes32 m2; |
| 13425 | bytes32 m3; |
| 13426 | bytes32 m4; |
| 13427 | bytes32 m5; |
| 13428 | bytes32 m6; |
| 13429 | bytes32 m7; |
| 13430 | bytes32 m8; |
| 13431 | bytes32 m9; |
| 13432 | bytes32 m10; |
| 13433 | /// @solidity memory-safe-assembly |
| 13434 | assembly { |
| 13435 | function writeString(pos, w) { |
| 13436 | let length := 0 |
| 13437 | for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } |
| 13438 | mstore(pos, length) |
| 13439 | let shift := sub(256, shl(3, length)) |
| 13440 | mstore(add(pos, 0x20), shl(shift, shr(shift, w))) |
| 13441 | } |
| 13442 | m0 := mload(0x00) |
| 13443 | m1 := mload(0x20) |
| 13444 | m2 := mload(0x40) |
| 13445 | m3 := mload(0x60) |
| 13446 | m4 := mload(0x80) |
| 13447 | m5 := mload(0xa0) |
| 13448 | m6 := mload(0xc0) |
| 13449 | m7 := mload(0xe0) |
| 13450 | m8 := mload(0x100) |
| 13451 | m9 := mload(0x120) |
| 13452 | m10 := mload(0x140) |
| 13453 | // Selector of `log(string,string,bool,string)`. |
| 13454 | mstore(0x00, 0x5e84b0ea) |
| 13455 | mstore(0x20, 0x80) |
| 13456 | mstore(0x40, 0xc0) |
| 13457 | mstore(0x60, p2) |
| 13458 | mstore(0x80, 0x100) |
| 13459 | writeString(0xa0, p0) |
| 13460 | writeString(0xe0, p1) |
| 13461 | writeString(0x120, p3) |
| 13462 | } |
| 13463 | _sendLogPayload(0x1c, 0x144); |
| 13464 | /// @solidity memory-safe-assembly |
| 13465 | assembly { |
| 13466 | mstore(0x00, m0) |
| 13467 | mstore(0x20, m1) |
| 13468 | mstore(0x40, m2) |
| 13469 | mstore(0x60, m3) |
| 13470 | mstore(0x80, m4) |
| 13471 | mstore(0xa0, m5) |
| 13472 | mstore(0xc0, m6) |
| 13473 | mstore(0xe0, m7) |
| 13474 | mstore(0x100, m8) |
| 13475 | mstore(0x120, m9) |
| 13476 | mstore(0x140, m10) |
| 13477 | } |
| 13478 | } |
| 13479 | |
| 13480 | function log(bytes32 p0, bytes32 p1, uint256 p2, address p3) internal pure { |
| 13481 | bytes32 m0; |
| 13482 | bytes32 m1; |
| 13483 | bytes32 m2; |
| 13484 | bytes32 m3; |
| 13485 | bytes32 m4; |
| 13486 | bytes32 m5; |
| 13487 | bytes32 m6; |
| 13488 | bytes32 m7; |
| 13489 | bytes32 m8; |
| 13490 | /// @solidity memory-safe-assembly |
| 13491 | assembly { |
| 13492 | function writeString(pos, w) { |
| 13493 | let length := 0 |
| 13494 | for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } |
| 13495 | mstore(pos, length) |
| 13496 | let shift := sub(256, shl(3, length)) |
| 13497 | mstore(add(pos, 0x20), shl(shift, shr(shift, w))) |
| 13498 | } |
| 13499 | m0 := mload(0x00) |
| 13500 | m1 := mload(0x20) |
| 13501 | m2 := mload(0x40) |
| 13502 | m3 := mload(0x60) |
| 13503 | m4 := mload(0x80) |
| 13504 | m5 := mload(0xa0) |
| 13505 | m6 := mload(0xc0) |
| 13506 | m7 := mload(0xe0) |
| 13507 | m8 := mload(0x100) |
| 13508 | // Selector of `log(string,string,uint256,address)`. |
| 13509 | mstore(0x00, 0x1023f7b2) |
| 13510 | mstore(0x20, 0x80) |
| 13511 | mstore(0x40, 0xc0) |
| 13512 | mstore(0x60, p2) |
| 13513 | mstore(0x80, p3) |
| 13514 | writeString(0xa0, p0) |
| 13515 | writeString(0xe0, p1) |
| 13516 | } |
| 13517 | _sendLogPayload(0x1c, 0x104); |
| 13518 | /// @solidity memory-safe-assembly |
| 13519 | assembly { |
| 13520 | mstore(0x00, m0) |
| 13521 | mstore(0x20, m1) |
| 13522 | mstore(0x40, m2) |
| 13523 | mstore(0x60, m3) |
| 13524 | mstore(0x80, m4) |
| 13525 | mstore(0xa0, m5) |
| 13526 | mstore(0xc0, m6) |
| 13527 | mstore(0xe0, m7) |
| 13528 | mstore(0x100, m8) |
| 13529 | } |
| 13530 | } |
| 13531 | |
| 13532 | function log(bytes32 p0, bytes32 p1, uint256 p2, bool p3) internal pure { |
| 13533 | bytes32 m0; |
| 13534 | bytes32 m1; |
| 13535 | bytes32 m2; |
| 13536 | bytes32 m3; |
| 13537 | bytes32 m4; |
| 13538 | bytes32 m5; |
| 13539 | bytes32 m6; |
| 13540 | bytes32 m7; |
| 13541 | bytes32 m8; |
| 13542 | /// @solidity memory-safe-assembly |
| 13543 | assembly { |
| 13544 | function writeString(pos, w) { |
| 13545 | let length := 0 |
| 13546 | for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } |
| 13547 | mstore(pos, length) |
| 13548 | let shift := sub(256, shl(3, length)) |
| 13549 | mstore(add(pos, 0x20), shl(shift, shr(shift, w))) |
| 13550 | } |
| 13551 | m0 := mload(0x00) |
| 13552 | m1 := mload(0x20) |
| 13553 | m2 := mload(0x40) |
| 13554 | m3 := mload(0x60) |
| 13555 | m4 := mload(0x80) |
| 13556 | m5 := mload(0xa0) |
| 13557 | m6 := mload(0xc0) |
| 13558 | m7 := mload(0xe0) |
| 13559 | m8 := mload(0x100) |
| 13560 | // Selector of `log(string,string,uint256,bool)`. |
| 13561 | mstore(0x00, 0xc3a8a654) |
| 13562 | mstore(0x20, 0x80) |
| 13563 | mstore(0x40, 0xc0) |
| 13564 | mstore(0x60, p2) |
| 13565 | mstore(0x80, p3) |
| 13566 | writeString(0xa0, p0) |
| 13567 | writeString(0xe0, p1) |
| 13568 | } |
| 13569 | _sendLogPayload(0x1c, 0x104); |
| 13570 | /// @solidity memory-safe-assembly |
| 13571 | assembly { |
| 13572 | mstore(0x00, m0) |
| 13573 | mstore(0x20, m1) |
| 13574 | mstore(0x40, m2) |
| 13575 | mstore(0x60, m3) |
| 13576 | mstore(0x80, m4) |
| 13577 | mstore(0xa0, m5) |
| 13578 | mstore(0xc0, m6) |
| 13579 | mstore(0xe0, m7) |
| 13580 | mstore(0x100, m8) |
| 13581 | } |
| 13582 | } |
| 13583 | |
| 13584 | function log(bytes32 p0, bytes32 p1, uint256 p2, uint256 p3) internal pure { |
| 13585 | bytes32 m0; |
| 13586 | bytes32 m1; |
| 13587 | bytes32 m2; |
| 13588 | bytes32 m3; |
| 13589 | bytes32 m4; |
| 13590 | bytes32 m5; |
| 13591 | bytes32 m6; |
| 13592 | bytes32 m7; |
| 13593 | bytes32 m8; |
| 13594 | /// @solidity memory-safe-assembly |
| 13595 | assembly { |
| 13596 | function writeString(pos, w) { |
| 13597 | let length := 0 |
| 13598 | for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } |
| 13599 | mstore(pos, length) |
| 13600 | let shift := sub(256, shl(3, length)) |
| 13601 | mstore(add(pos, 0x20), shl(shift, shr(shift, w))) |
| 13602 | } |
| 13603 | m0 := mload(0x00) |
| 13604 | m1 := mload(0x20) |
| 13605 | m2 := mload(0x40) |
| 13606 | m3 := mload(0x60) |
| 13607 | m4 := mload(0x80) |
| 13608 | m5 := mload(0xa0) |
| 13609 | m6 := mload(0xc0) |
| 13610 | m7 := mload(0xe0) |
| 13611 | m8 := mload(0x100) |
| 13612 | // Selector of `log(string,string,uint256,uint256)`. |
| 13613 | mstore(0x00, 0xf45d7d2c) |
| 13614 | mstore(0x20, 0x80) |
| 13615 | mstore(0x40, 0xc0) |
| 13616 | mstore(0x60, p2) |
| 13617 | mstore(0x80, p3) |
| 13618 | writeString(0xa0, p0) |
| 13619 | writeString(0xe0, p1) |
| 13620 | } |
| 13621 | _sendLogPayload(0x1c, 0x104); |
| 13622 | /// @solidity memory-safe-assembly |
| 13623 | assembly { |
| 13624 | mstore(0x00, m0) |
| 13625 | mstore(0x20, m1) |
| 13626 | mstore(0x40, m2) |
| 13627 | mstore(0x60, m3) |
| 13628 | mstore(0x80, m4) |
| 13629 | mstore(0xa0, m5) |
| 13630 | mstore(0xc0, m6) |
| 13631 | mstore(0xe0, m7) |
| 13632 | mstore(0x100, m8) |
| 13633 | } |
| 13634 | } |
| 13635 | |
| 13636 | function log(bytes32 p0, bytes32 p1, uint256 p2, bytes32 p3) internal pure { |
| 13637 | bytes32 m0; |
| 13638 | bytes32 m1; |
| 13639 | bytes32 m2; |
| 13640 | bytes32 m3; |
| 13641 | bytes32 m4; |
| 13642 | bytes32 m5; |
| 13643 | bytes32 m6; |
| 13644 | bytes32 m7; |
| 13645 | bytes32 m8; |
| 13646 | bytes32 m9; |
| 13647 | bytes32 m10; |
| 13648 | /// @solidity memory-safe-assembly |
| 13649 | assembly { |
| 13650 | function writeString(pos, w) { |
| 13651 | let length := 0 |
| 13652 | for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } |
| 13653 | mstore(pos, length) |
| 13654 | let shift := sub(256, shl(3, length)) |
| 13655 | mstore(add(pos, 0x20), shl(shift, shr(shift, w))) |
| 13656 | } |
| 13657 | m0 := mload(0x00) |
| 13658 | m1 := mload(0x20) |
| 13659 | m2 := mload(0x40) |
| 13660 | m3 := mload(0x60) |
| 13661 | m4 := mload(0x80) |
| 13662 | m5 := mload(0xa0) |
| 13663 | m6 := mload(0xc0) |
| 13664 | m7 := mload(0xe0) |
| 13665 | m8 := mload(0x100) |
| 13666 | m9 := mload(0x120) |
| 13667 | m10 := mload(0x140) |
| 13668 | // Selector of `log(string,string,uint256,string)`. |
| 13669 | mstore(0x00, 0x5d1a971a) |
| 13670 | mstore(0x20, 0x80) |
| 13671 | mstore(0x40, 0xc0) |
| 13672 | mstore(0x60, p2) |
| 13673 | mstore(0x80, 0x100) |
| 13674 | writeString(0xa0, p0) |
| 13675 | writeString(0xe0, p1) |
| 13676 | writeString(0x120, p3) |
| 13677 | } |
| 13678 | _sendLogPayload(0x1c, 0x144); |
| 13679 | /// @solidity memory-safe-assembly |
| 13680 | assembly { |
| 13681 | mstore(0x00, m0) |
| 13682 | mstore(0x20, m1) |
| 13683 | mstore(0x40, m2) |
| 13684 | mstore(0x60, m3) |
| 13685 | mstore(0x80, m4) |
| 13686 | mstore(0xa0, m5) |
| 13687 | mstore(0xc0, m6) |
| 13688 | mstore(0xe0, m7) |
| 13689 | mstore(0x100, m8) |
| 13690 | mstore(0x120, m9) |
| 13691 | mstore(0x140, m10) |
| 13692 | } |
| 13693 | } |
| 13694 | |
| 13695 | function log(bytes32 p0, bytes32 p1, bytes32 p2, address p3) internal pure { |
| 13696 | bytes32 m0; |
| 13697 | bytes32 m1; |
| 13698 | bytes32 m2; |
| 13699 | bytes32 m3; |
| 13700 | bytes32 m4; |
| 13701 | bytes32 m5; |
| 13702 | bytes32 m6; |
| 13703 | bytes32 m7; |
| 13704 | bytes32 m8; |
| 13705 | bytes32 m9; |
| 13706 | bytes32 m10; |
| 13707 | /// @solidity memory-safe-assembly |
| 13708 | assembly { |
| 13709 | function writeString(pos, w) { |
| 13710 | let length := 0 |
| 13711 | for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } |
| 13712 | mstore(pos, length) |
| 13713 | let shift := sub(256, shl(3, length)) |
| 13714 | mstore(add(pos, 0x20), shl(shift, shr(shift, w))) |
| 13715 | } |
| 13716 | m0 := mload(0x00) |
| 13717 | m1 := mload(0x20) |
| 13718 | m2 := mload(0x40) |
| 13719 | m3 := mload(0x60) |
| 13720 | m4 := mload(0x80) |
| 13721 | m5 := mload(0xa0) |
| 13722 | m6 := mload(0xc0) |
| 13723 | m7 := mload(0xe0) |
| 13724 | m8 := mload(0x100) |
| 13725 | m9 := mload(0x120) |
| 13726 | m10 := mload(0x140) |
| 13727 | // Selector of `log(string,string,string,address)`. |
| 13728 | mstore(0x00, 0x6d572f44) |
| 13729 | mstore(0x20, 0x80) |
| 13730 | mstore(0x40, 0xc0) |
| 13731 | mstore(0x60, 0x100) |
| 13732 | mstore(0x80, p3) |
| 13733 | writeString(0xa0, p0) |
| 13734 | writeString(0xe0, p1) |
| 13735 | writeString(0x120, p2) |
| 13736 | } |
| 13737 | _sendLogPayload(0x1c, 0x144); |
| 13738 | /// @solidity memory-safe-assembly |
| 13739 | assembly { |
| 13740 | mstore(0x00, m0) |
| 13741 | mstore(0x20, m1) |
| 13742 | mstore(0x40, m2) |
| 13743 | mstore(0x60, m3) |
| 13744 | mstore(0x80, m4) |
| 13745 | mstore(0xa0, m5) |
| 13746 | mstore(0xc0, m6) |
| 13747 | mstore(0xe0, m7) |
| 13748 | mstore(0x100, m8) |
| 13749 | mstore(0x120, m9) |
| 13750 | mstore(0x140, m10) |
| 13751 | } |
| 13752 | } |
| 13753 | |
| 13754 | function log(bytes32 p0, bytes32 p1, bytes32 p2, bool p3) internal pure { |
| 13755 | bytes32 m0; |
| 13756 | bytes32 m1; |
| 13757 | bytes32 m2; |
| 13758 | bytes32 m3; |
| 13759 | bytes32 m4; |
| 13760 | bytes32 m5; |
| 13761 | bytes32 m6; |
| 13762 | bytes32 m7; |
| 13763 | bytes32 m8; |
| 13764 | bytes32 m9; |
| 13765 | bytes32 m10; |
| 13766 | /// @solidity memory-safe-assembly |
| 13767 | assembly { |
| 13768 | function writeString(pos, w) { |
| 13769 | let length := 0 |
| 13770 | for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } |
| 13771 | mstore(pos, length) |
| 13772 | let shift := sub(256, shl(3, length)) |
| 13773 | mstore(add(pos, 0x20), shl(shift, shr(shift, w))) |
| 13774 | } |
| 13775 | m0 := mload(0x00) |
| 13776 | m1 := mload(0x20) |
| 13777 | m2 := mload(0x40) |
| 13778 | m3 := mload(0x60) |
| 13779 | m4 := mload(0x80) |
| 13780 | m5 := mload(0xa0) |
| 13781 | m6 := mload(0xc0) |
| 13782 | m7 := mload(0xe0) |
| 13783 | m8 := mload(0x100) |
| 13784 | m9 := mload(0x120) |
| 13785 | m10 := mload(0x140) |
| 13786 | // Selector of `log(string,string,string,bool)`. |
| 13787 | mstore(0x00, 0x2c1754ed) |
| 13788 | mstore(0x20, 0x80) |
| 13789 | mstore(0x40, 0xc0) |
| 13790 | mstore(0x60, 0x100) |
| 13791 | mstore(0x80, p3) |
| 13792 | writeString(0xa0, p0) |
| 13793 | writeString(0xe0, p1) |
| 13794 | writeString(0x120, p2) |
| 13795 | } |
| 13796 | _sendLogPayload(0x1c, 0x144); |
| 13797 | /// @solidity memory-safe-assembly |
| 13798 | assembly { |
| 13799 | mstore(0x00, m0) |
| 13800 | mstore(0x20, m1) |
| 13801 | mstore(0x40, m2) |
| 13802 | mstore(0x60, m3) |
| 13803 | mstore(0x80, m4) |
| 13804 | mstore(0xa0, m5) |
| 13805 | mstore(0xc0, m6) |
| 13806 | mstore(0xe0, m7) |
| 13807 | mstore(0x100, m8) |
| 13808 | mstore(0x120, m9) |
| 13809 | mstore(0x140, m10) |
| 13810 | } |
| 13811 | } |
| 13812 | |
| 13813 | function log(bytes32 p0, bytes32 p1, bytes32 p2, uint256 p3) internal pure { |
| 13814 | bytes32 m0; |
| 13815 | bytes32 m1; |
| 13816 | bytes32 m2; |
| 13817 | bytes32 m3; |
| 13818 | bytes32 m4; |
| 13819 | bytes32 m5; |
| 13820 | bytes32 m6; |
| 13821 | bytes32 m7; |
| 13822 | bytes32 m8; |
| 13823 | bytes32 m9; |
| 13824 | bytes32 m10; |
| 13825 | /// @solidity memory-safe-assembly |
| 13826 | assembly { |
| 13827 | function writeString(pos, w) { |
| 13828 | let length := 0 |
| 13829 | for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } |
| 13830 | mstore(pos, length) |
| 13831 | let shift := sub(256, shl(3, length)) |
| 13832 | mstore(add(pos, 0x20), shl(shift, shr(shift, w))) |
| 13833 | } |
| 13834 | m0 := mload(0x00) |
| 13835 | m1 := mload(0x20) |
| 13836 | m2 := mload(0x40) |
| 13837 | m3 := mload(0x60) |
| 13838 | m4 := mload(0x80) |
| 13839 | m5 := mload(0xa0) |
| 13840 | m6 := mload(0xc0) |
| 13841 | m7 := mload(0xe0) |
| 13842 | m8 := mload(0x100) |
| 13843 | m9 := mload(0x120) |
| 13844 | m10 := mload(0x140) |
| 13845 | // Selector of `log(string,string,string,uint256)`. |
| 13846 | mstore(0x00, 0x8eafb02b) |
| 13847 | mstore(0x20, 0x80) |
| 13848 | mstore(0x40, 0xc0) |
| 13849 | mstore(0x60, 0x100) |
| 13850 | mstore(0x80, p3) |
| 13851 | writeString(0xa0, p0) |
| 13852 | writeString(0xe0, p1) |
| 13853 | writeString(0x120, p2) |
| 13854 | } |
| 13855 | _sendLogPayload(0x1c, 0x144); |
| 13856 | /// @solidity memory-safe-assembly |
| 13857 | assembly { |
| 13858 | mstore(0x00, m0) |
| 13859 | mstore(0x20, m1) |
| 13860 | mstore(0x40, m2) |
| 13861 | mstore(0x60, m3) |
| 13862 | mstore(0x80, m4) |
| 13863 | mstore(0xa0, m5) |
| 13864 | mstore(0xc0, m6) |
| 13865 | mstore(0xe0, m7) |
| 13866 | mstore(0x100, m8) |
| 13867 | mstore(0x120, m9) |
| 13868 | mstore(0x140, m10) |
| 13869 | } |
| 13870 | } |
| 13871 | |
| 13872 | function log(bytes32 p0, bytes32 p1, bytes32 p2, bytes32 p3) internal pure { |
| 13873 | bytes32 m0; |
| 13874 | bytes32 m1; |
| 13875 | bytes32 m2; |
| 13876 | bytes32 m3; |
| 13877 | bytes32 m4; |
| 13878 | bytes32 m5; |
| 13879 | bytes32 m6; |
| 13880 | bytes32 m7; |
| 13881 | bytes32 m8; |
| 13882 | bytes32 m9; |
| 13883 | bytes32 m10; |
| 13884 | bytes32 m11; |
| 13885 | bytes32 m12; |
| 13886 | /// @solidity memory-safe-assembly |
| 13887 | assembly { |
| 13888 | function writeString(pos, w) { |
| 13889 | let length := 0 |
| 13890 | for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } |
| 13891 | mstore(pos, length) |
| 13892 | let shift := sub(256, shl(3, length)) |
| 13893 | mstore(add(pos, 0x20), shl(shift, shr(shift, w))) |
| 13894 | } |
| 13895 | m0 := mload(0x00) |
| 13896 | m1 := mload(0x20) |
| 13897 | m2 := mload(0x40) |
| 13898 | m3 := mload(0x60) |
| 13899 | m4 := mload(0x80) |
| 13900 | m5 := mload(0xa0) |
| 13901 | m6 := mload(0xc0) |
| 13902 | m7 := mload(0xe0) |
| 13903 | m8 := mload(0x100) |
| 13904 | m9 := mload(0x120) |
| 13905 | m10 := mload(0x140) |
| 13906 | m11 := mload(0x160) |
| 13907 | m12 := mload(0x180) |
| 13908 | // Selector of `log(string,string,string,string)`. |
| 13909 | mstore(0x00, 0xde68f20a) |
| 13910 | mstore(0x20, 0x80) |
| 13911 | mstore(0x40, 0xc0) |
| 13912 | mstore(0x60, 0x100) |
| 13913 | mstore(0x80, 0x140) |
| 13914 | writeString(0xa0, p0) |
| 13915 | writeString(0xe0, p1) |
| 13916 | writeString(0x120, p2) |
| 13917 | writeString(0x160, p3) |
| 13918 | } |
| 13919 | _sendLogPayload(0x1c, 0x184); |
| 13920 | /// @solidity memory-safe-assembly |
| 13921 | assembly { |
| 13922 | mstore(0x00, m0) |
| 13923 | mstore(0x20, m1) |
| 13924 | mstore(0x40, m2) |
| 13925 | mstore(0x60, m3) |
| 13926 | mstore(0x80, m4) |
| 13927 | mstore(0xa0, m5) |
| 13928 | mstore(0xc0, m6) |
| 13929 | mstore(0xe0, m7) |
| 13930 | mstore(0x100, m8) |
| 13931 | mstore(0x120, m9) |
| 13932 | mstore(0x140, m10) |
| 13933 | mstore(0x160, m11) |
| 13934 | mstore(0x180, m12) |
| 13935 | } |
| 13936 | } |
| 13937 | } |
| 13938 |
60.0%
lib/openzeppelin-contracts/contracts/access/Ownable.sol
Lines covered: 6 / 10 (60.0%)
| 1 | // SPDX-License-Identifier: MIT |
| 2 | // OpenZeppelin Contracts (last updated v5.0.0) (access/Ownable.sol) |
| 3 | |
| 4 | pragma solidity ^0.8.20; |
| 5 | |
| 6 | import {Context} from "../utils/Context.sol"; |
| 7 | |
| 8 | /** |
| 9 | * @dev Contract module which provides a basic access control mechanism, where |
| 10 | * there is an account (an owner) that can be granted exclusive access to |
| 11 | * specific functions. |
| 12 | * |
| 13 | * The initial owner is set to the address provided by the deployer. This can |
| 14 | * later be changed with {transferOwnership}. |
| 15 | * |
| 16 | * This module is used through inheritance. It will make available the modifier |
| 17 | * `onlyOwner`, which can be applied to your functions to restrict their use to |
| 18 | * the owner. |
| 19 | */ |
| 20 | abstract contract Ownable is Context { |
| 21 | address private _owner; |
| 22 | |
| 23 | /** |
| 24 | * @dev The caller account is not authorized to perform an operation. |
| 25 | */ |
| 26 | error OwnableUnauthorizedAccount(address account); |
| 27 | |
| 28 | /** |
| 29 | * @dev The owner is not a valid owner account. (eg. `address(0)`) |
| 30 | */ |
| 31 | error OwnableInvalidOwner(address owner); |
| 32 | |
| 33 | event OwnershipTransferred(address indexed previousOwner, address indexed newOwner); |
| 34 | |
| 35 | /** |
| 36 | * @dev Initializes the contract setting the address provided by the deployer as the initial owner. |
| 37 | */ |
| 38 | constructor(address initialOwner) { |
| 39 | if (initialOwner == address(0)) { |
| 40 | revert OwnableInvalidOwner(address(0)); |
| 41 | } |
| 42 | _transferOwnership(initialOwner); |
| 43 | } |
| 44 | |
| 45 | /** |
| 46 | * @dev Throws if called by any account other than the owner. |
| 47 | */ |
| 48 | modifier onlyOwner() { |
| 49 | _checkOwner(); |
| 50 | _; |
| 51 | } |
| 52 | |
| 53 | /** |
| 54 | * @dev Returns the address of the current owner. |
| 55 | */ |
| 56 | function owner() public view virtual returns (address) { |
| 57 | return _owner; |
| 58 | } |
| 59 | |
| 60 | /** |
| 61 | * @dev Throws if the sender is not the owner. |
| 62 | */ |
| 63 | function _checkOwner() internal view virtual { |
| 64 | if (owner() != _msgSender()) { |
| 65 | revert OwnableUnauthorizedAccount(_msgSender()); |
| 66 | } |
| 67 | } |
| 68 | |
| 69 | /** |
| 70 | * @dev Leaves the contract without owner. It will not be possible to call |
| 71 | * `onlyOwner` functions. Can only be called by the current owner. |
| 72 | * |
| 73 | * NOTE: Renouncing ownership will leave the contract without an owner, |
| 74 | * thereby disabling any functionality that is only available to the owner. |
| 75 | */ |
| 76 | function renounceOwnership() public virtual onlyOwner { |
| 77 | _transferOwnership(address(0)); |
| 78 | } |
| 79 | |
| 80 | /** |
| 81 | * @dev Transfers ownership of the contract to a new account (`newOwner`). |
| 82 | * Can only be called by the current owner. |
| 83 | */ |
| 84 | function transferOwnership(address newOwner) public virtual onlyOwner { |
| 85 | if (newOwner == address(0)) { |
| 86 | revert OwnableInvalidOwner(address(0)); |
| 87 | } |
| 88 | _transferOwnership(newOwner); |
| 89 | } |
| 90 | |
| 91 | /** |
| 92 | * @dev Transfers ownership of the contract to a new account (`newOwner`). |
| 93 | * Internal function without access restriction. |
| 94 | */ |
| 95 | function _transferOwnership(address newOwner) internal virtual { |
| 96 | address oldOwner = _owner; |
| 97 | _owner = newOwner; |
| 98 | emit OwnershipTransferred(oldOwner, newOwner); |
| 99 | } |
| 100 | } |
| 101 |
0.0%
lib/openzeppelin-contracts/contracts/interfaces/IERC1363.sol
Lines covered: 0 / 0 (0.0%)
| 1 | // SPDX-License-Identifier: MIT |
| 2 | // OpenZeppelin Contracts (last updated v5.4.0) (interfaces/IERC1363.sol) |
| 3 | |
| 4 | pragma solidity >=0.6.2; |
| 5 | |
| 6 | import {IERC20} from "./IERC20.sol"; |
| 7 | import {IERC165} from "./IERC165.sol"; |
| 8 | |
| 9 | /** |
| 10 | * @title IERC1363 |
| 11 | * @dev Interface of the ERC-1363 standard as defined in the https://eips.ethereum.org/EIPS/eip-1363[ERC-1363]. |
| 12 | * |
| 13 | * Defines an extension interface for ERC-20 tokens that supports executing code on a recipient contract |
| 14 | * after `transfer` or `transferFrom`, or code on a spender contract after `approve`, in a single transaction. |
| 15 | */ |
| 16 | interface IERC1363 is IERC20, IERC165 { |
| 17 | /* |
| 18 | * Note: the ERC-165 identifier for this interface is 0xb0202a11. |
| 19 | * 0xb0202a11 === |
| 20 | * bytes4(keccak256('transferAndCall(address,uint256)')) ^ |
| 21 | * bytes4(keccak256('transferAndCall(address,uint256,bytes)')) ^ |
| 22 | * bytes4(keccak256('transferFromAndCall(address,address,uint256)')) ^ |
| 23 | * bytes4(keccak256('transferFromAndCall(address,address,uint256,bytes)')) ^ |
| 24 | * bytes4(keccak256('approveAndCall(address,uint256)')) ^ |
| 25 | * bytes4(keccak256('approveAndCall(address,uint256,bytes)')) |
| 26 | */ |
| 27 | |
| 28 | /** |
| 29 | * @dev Moves a `value` amount of tokens from the caller's account to `to` |
| 30 | * and then calls {IERC1363Receiver-onTransferReceived} on `to`. |
| 31 | * @param to The address which you want to transfer to. |
| 32 | * @param value The amount of tokens to be transferred. |
| 33 | * @return A boolean value indicating whether the operation succeeded unless throwing. |
| 34 | */ |
| 35 | function transferAndCall(address to, uint256 value) external returns (bool); |
| 36 | |
| 37 | /** |
| 38 | * @dev Moves a `value` amount of tokens from the caller's account to `to` |
| 39 | * and then calls {IERC1363Receiver-onTransferReceived} on `to`. |
| 40 | * @param to The address which you want to transfer to. |
| 41 | * @param value The amount of tokens to be transferred. |
| 42 | * @param data Additional data with no specified format, sent in call to `to`. |
| 43 | * @return A boolean value indicating whether the operation succeeded unless throwing. |
| 44 | */ |
| 45 | function transferAndCall(address to, uint256 value, bytes calldata data) external returns (bool); |
| 46 | |
| 47 | /** |
| 48 | * @dev Moves a `value` amount of tokens from `from` to `to` using the allowance mechanism |
| 49 | * and then calls {IERC1363Receiver-onTransferReceived} on `to`. |
| 50 | * @param from The address which you want to send tokens from. |
| 51 | * @param to The address which you want to transfer to. |
| 52 | * @param value The amount of tokens to be transferred. |
| 53 | * @return A boolean value indicating whether the operation succeeded unless throwing. |
| 54 | */ |
| 55 | function transferFromAndCall(address from, address to, uint256 value) external returns (bool); |
| 56 | |
| 57 | /** |
| 58 | * @dev Moves a `value` amount of tokens from `from` to `to` using the allowance mechanism |
| 59 | * and then calls {IERC1363Receiver-onTransferReceived} on `to`. |
| 60 | * @param from The address which you want to send tokens from. |
| 61 | * @param to The address which you want to transfer to. |
| 62 | * @param value The amount of tokens to be transferred. |
| 63 | * @param data Additional data with no specified format, sent in call to `to`. |
| 64 | * @return A boolean value indicating whether the operation succeeded unless throwing. |
| 65 | */ |
| 66 | function transferFromAndCall(address from, address to, uint256 value, bytes calldata data) external returns (bool); |
| 67 | |
| 68 | /** |
| 69 | * @dev Sets a `value` amount of tokens as the allowance of `spender` over the |
| 70 | * caller's tokens and then calls {IERC1363Spender-onApprovalReceived} on `spender`. |
| 71 | * @param spender The address which will spend the funds. |
| 72 | * @param value The amount of tokens to be spent. |
| 73 | * @return A boolean value indicating whether the operation succeeded unless throwing. |
| 74 | */ |
| 75 | function approveAndCall(address spender, uint256 value) external returns (bool); |
| 76 | |
| 77 | /** |
| 78 | * @dev Sets a `value` amount of tokens as the allowance of `spender` over the |
| 79 | * caller's tokens and then calls {IERC1363Spender-onApprovalReceived} on `spender`. |
| 80 | * @param spender The address which will spend the funds. |
| 81 | * @param value The amount of tokens to be spent. |
| 82 | * @param data Additional data with no specified format, sent in call to `spender`. |
| 83 | * @return A boolean value indicating whether the operation succeeded unless throwing. |
| 84 | */ |
| 85 | function approveAndCall(address spender, uint256 value, bytes calldata data) external returns (bool); |
| 86 | } |
| 87 |
0.0%
lib/openzeppelin-contracts/contracts/interfaces/IERC165.sol
Lines covered: 0 / 0 (0.0%)
| 1 | // SPDX-License-Identifier: MIT |
| 2 | // OpenZeppelin Contracts (last updated v5.4.0) (interfaces/IERC165.sol) |
| 3 | |
| 4 | pragma solidity >=0.4.16; |
| 5 | |
| 6 | import {IERC165} from "../utils/introspection/IERC165.sol"; |
| 7 |
0.0%
lib/openzeppelin-contracts/contracts/interfaces/IERC20.sol
Lines covered: 0 / 0 (0.0%)
| 1 | // SPDX-License-Identifier: MIT |
| 2 | // OpenZeppelin Contracts (last updated v5.4.0) (interfaces/IERC20.sol) |
| 3 | |
| 4 | pragma solidity >=0.4.16; |
| 5 | |
| 6 | import {IERC20} from "../token/ERC20/IERC20.sol"; |
| 7 |
0.0%
lib/openzeppelin-contracts/contracts/interfaces/draft-IERC6093.sol
Lines covered: 0 / 0 (0.0%)
| 1 | // SPDX-License-Identifier: MIT |
| 2 | // OpenZeppelin Contracts (last updated v5.5.0) (interfaces/draft-IERC6093.sol) |
| 3 | |
| 4 | pragma solidity >=0.8.4; |
| 5 | |
| 6 | /** |
| 7 | * @dev Standard ERC-20 Errors |
| 8 | * Interface of the https://eips.ethereum.org/EIPS/eip-6093[ERC-6093] custom errors for ERC-20 tokens. |
| 9 | */ |
| 10 | interface IERC20Errors { |
| 11 | /** |
| 12 | * @dev Indicates an error related to the current `balance` of a `sender`. Used in transfers. |
| 13 | * @param sender Address whose tokens are being transferred. |
| 14 | * @param balance Current balance for the interacting account. |
| 15 | * @param needed Minimum amount required to perform a transfer. |
| 16 | */ |
| 17 | error ERC20InsufficientBalance(address sender, uint256 balance, uint256 needed); |
| 18 | |
| 19 | /** |
| 20 | * @dev Indicates a failure with the token `sender`. Used in transfers. |
| 21 | * @param sender Address whose tokens are being transferred. |
| 22 | */ |
| 23 | error ERC20InvalidSender(address sender); |
| 24 | |
| 25 | /** |
| 26 | * @dev Indicates a failure with the token `receiver`. Used in transfers. |
| 27 | * @param receiver Address to which tokens are being transferred. |
| 28 | */ |
| 29 | error ERC20InvalidReceiver(address receiver); |
| 30 | |
| 31 | /** |
| 32 | * @dev Indicates a failure with the `spender`’s `allowance`. Used in transfers. |
| 33 | * @param spender Address that may be allowed to operate on tokens without being their owner. |
| 34 | * @param allowance Amount of tokens a `spender` is allowed to operate with. |
| 35 | * @param needed Minimum amount required to perform a transfer. |
| 36 | */ |
| 37 | error ERC20InsufficientAllowance(address spender, uint256 allowance, uint256 needed); |
| 38 | |
| 39 | /** |
| 40 | * @dev Indicates a failure with the `approver` of a token to be approved. Used in approvals. |
| 41 | * @param approver Address initiating an approval operation. |
| 42 | */ |
| 43 | error ERC20InvalidApprover(address approver); |
| 44 | |
| 45 | /** |
| 46 | * @dev Indicates a failure with the `spender` to be approved. Used in approvals. |
| 47 | * @param spender Address that may be allowed to operate on tokens without being their owner. |
| 48 | */ |
| 49 | error ERC20InvalidSpender(address spender); |
| 50 | } |
| 51 | |
| 52 | /** |
| 53 | * @dev Standard ERC-721 Errors |
| 54 | * Interface of the https://eips.ethereum.org/EIPS/eip-6093[ERC-6093] custom errors for ERC-721 tokens. |
| 55 | */ |
| 56 | interface IERC721Errors { |
| 57 | /** |
| 58 | * @dev Indicates that an address can't be an owner. For example, `address(0)` is a forbidden owner in ERC-721. |
| 59 | * Used in balance queries. |
| 60 | * @param owner Address of the current owner of a token. |
| 61 | */ |
| 62 | error ERC721InvalidOwner(address owner); |
| 63 | |
| 64 | /** |
| 65 | * @dev Indicates a `tokenId` whose `owner` is the zero address. |
| 66 | * @param tokenId Identifier number of a token. |
| 67 | */ |
| 68 | error ERC721NonexistentToken(uint256 tokenId); |
| 69 | |
| 70 | /** |
| 71 | * @dev Indicates an error related to the ownership over a particular token. Used in transfers. |
| 72 | * @param sender Address whose tokens are being transferred. |
| 73 | * @param tokenId Identifier number of a token. |
| 74 | * @param owner Address of the current owner of a token. |
| 75 | */ |
| 76 | error ERC721IncorrectOwner(address sender, uint256 tokenId, address owner); |
| 77 | |
| 78 | /** |
| 79 | * @dev Indicates a failure with the token `sender`. Used in transfers. |
| 80 | * @param sender Address whose tokens are being transferred. |
| 81 | */ |
| 82 | error ERC721InvalidSender(address sender); |
| 83 | |
| 84 | /** |
| 85 | * @dev Indicates a failure with the token `receiver`. Used in transfers. |
| 86 | * @param receiver Address to which tokens are being transferred. |
| 87 | */ |
| 88 | error ERC721InvalidReceiver(address receiver); |
| 89 | |
| 90 | /** |
| 91 | * @dev Indicates a failure with the `operator`’s approval. Used in transfers. |
| 92 | * @param operator Address that may be allowed to operate on tokens without being their owner. |
| 93 | * @param tokenId Identifier number of a token. |
| 94 | */ |
| 95 | error ERC721InsufficientApproval(address operator, uint256 tokenId); |
| 96 | |
| 97 | /** |
| 98 | * @dev Indicates a failure with the `approver` of a token to be approved. Used in approvals. |
| 99 | * @param approver Address initiating an approval operation. |
| 100 | */ |
| 101 | error ERC721InvalidApprover(address approver); |
| 102 | |
| 103 | /** |
| 104 | * @dev Indicates a failure with the `operator` to be approved. Used in approvals. |
| 105 | * @param operator Address that may be allowed to operate on tokens without being their owner. |
| 106 | */ |
| 107 | error ERC721InvalidOperator(address operator); |
| 108 | } |
| 109 | |
| 110 | /** |
| 111 | * @dev Standard ERC-1155 Errors |
| 112 | * Interface of the https://eips.ethereum.org/EIPS/eip-6093[ERC-6093] custom errors for ERC-1155 tokens. |
| 113 | */ |
| 114 | interface IERC1155Errors { |
| 115 | /** |
| 116 | * @dev Indicates an error related to the current `balance` of a `sender`. Used in transfers. |
| 117 | * @param sender Address whose tokens are being transferred. |
| 118 | * @param balance Current balance for the interacting account. |
| 119 | * @param needed Minimum amount required to perform a transfer. |
| 120 | * @param tokenId Identifier number of a token. |
| 121 | */ |
| 122 | error ERC1155InsufficientBalance(address sender, uint256 balance, uint256 needed, uint256 tokenId); |
| 123 | |
| 124 | /** |
| 125 | * @dev Indicates a failure with the token `sender`. Used in transfers. |
| 126 | * @param sender Address whose tokens are being transferred. |
| 127 | */ |
| 128 | error ERC1155InvalidSender(address sender); |
| 129 | |
| 130 | /** |
| 131 | * @dev Indicates a failure with the token `receiver`. Used in transfers. |
| 132 | * @param receiver Address to which tokens are being transferred. |
| 133 | */ |
| 134 | error ERC1155InvalidReceiver(address receiver); |
| 135 | |
| 136 | /** |
| 137 | * @dev Indicates a failure with the `operator`’s approval. Used in transfers. |
| 138 | * @param operator Address that may be allowed to operate on tokens without being their owner. |
| 139 | * @param owner Address of the current owner of a token. |
| 140 | */ |
| 141 | error ERC1155MissingApprovalForAll(address operator, address owner); |
| 142 | |
| 143 | /** |
| 144 | * @dev Indicates a failure with the `approver` of a token to be approved. Used in approvals. |
| 145 | * @param approver Address initiating an approval operation. |
| 146 | */ |
| 147 | error ERC1155InvalidApprover(address approver); |
| 148 | |
| 149 | /** |
| 150 | * @dev Indicates a failure with the `operator` to be approved. Used in approvals. |
| 151 | * @param operator Address that may be allowed to operate on tokens without being their owner. |
| 152 | */ |
| 153 | error ERC1155InvalidOperator(address operator); |
| 154 | |
| 155 | /** |
| 156 | * @dev Indicates an array length mismatch between ids and values in a safeBatchTransferFrom operation. |
| 157 | * Used in batch transfers. |
| 158 | * @param idsLength Length of the array of token identifiers |
| 159 | * @param valuesLength Length of the array of token amounts |
| 160 | */ |
| 161 | error ERC1155InvalidArrayLength(uint256 idsLength, uint256 valuesLength); |
| 162 | } |
| 163 |
100.0%
lib/openzeppelin-contracts/contracts/mocks/token/ERC20Mock.sol
Lines covered: 1 / 1 (100.0%)
| 1 | // SPDX-License-Identifier: MIT |
| 2 | pragma solidity ^0.8.20; |
| 3 | |
| 4 | import {ERC20} from "../../token/ERC20/ERC20.sol"; |
| 5 | |
| 6 | contract ERC20Mock is ERC20 { |
| 7 | constructor() ERC20("ERC20Mock", "E20M") {} |
| 8 | |
| 9 | function mint(address account, uint256 amount) external { |
| 10 | _mint(account, amount); |
| 11 | } |
| 12 | |
| 13 | function burn(address account, uint256 amount) external { |
| 14 | _burn(account, amount); |
| 15 | } |
| 16 | } |
| 17 |
19.0%
lib/openzeppelin-contracts/contracts/token/ERC20/ERC20.sol
Lines covered: 5 / 26 (19.0%)
| 1 | // SPDX-License-Identifier: MIT |
| 2 | // OpenZeppelin Contracts (last updated v5.5.0) (token/ERC20/ERC20.sol) |
| 3 | |
| 4 | pragma solidity ^0.8.20; |
| 5 | |
| 6 | import {IERC20} from "./IERC20.sol"; |
| 7 | import {IERC20Metadata} from "./extensions/IERC20Metadata.sol"; |
| 8 | import {Context} from "../../utils/Context.sol"; |
| 9 | import {IERC20Errors} from "../../interfaces/draft-IERC6093.sol"; |
| 10 | |
| 11 | /** |
| 12 | * @dev Implementation of the {IERC20} interface. |
| 13 | * |
| 14 | * This implementation is agnostic to the way tokens are created. This means |
| 15 | * that a supply mechanism has to be added in a derived contract using {_mint}. |
| 16 | * |
| 17 | * TIP: For a detailed writeup see our guide |
| 18 | * https://forum.openzeppelin.com/t/how-to-implement-erc20-supply-mechanisms/226[How |
| 19 | * to implement supply mechanisms]. |
| 20 | * |
| 21 | * The default value of {decimals} is 18. To change this, you should override |
| 22 | * this function so it returns a different value. |
| 23 | * |
| 24 | * We have followed general OpenZeppelin Contracts guidelines: functions revert |
| 25 | * instead returning `false` on failure. This behavior is nonetheless |
| 26 | * conventional and does not conflict with the expectations of ERC-20 |
| 27 | * applications. |
| 28 | */ |
| 29 | abstract contract ERC20 is Context, IERC20, IERC20Metadata, IERC20Errors { |
| 30 | mapping(address account => uint256) private _balances; |
| 31 | |
| 32 | mapping(address account => mapping(address spender => uint256)) private _allowances; |
| 33 | |
| 34 | uint256 private _totalSupply; |
| 35 | |
| 36 | string private _name; |
| 37 | string private _symbol; |
| 38 | |
| 39 | /** |
| 40 | * @dev Sets the values for {name} and {symbol}. |
| 41 | * |
| 42 | * Both values are immutable: they can only be set once during construction. |
| 43 | */ |
| 44 | constructor(string memory name_, string memory symbol_) { |
| 45 | _name = name_; |
| 46 | _symbol = symbol_; |
| 47 | } |
| 48 | |
| 49 | /** |
| 50 | * @dev Returns the name of the token. |
| 51 | */ |
| 52 | function name() public view virtual returns (string memory) { |
| 53 | return _name; |
| 54 | } |
| 55 | |
| 56 | /** |
| 57 | * @dev Returns the symbol of the token, usually a shorter version of the |
| 58 | * name. |
| 59 | */ |
| 60 | function symbol() public view virtual returns (string memory) { |
| 61 | return _symbol; |
| 62 | } |
| 63 | |
| 64 | /** |
| 65 | * @dev Returns the number of decimals used to get its user representation. |
| 66 | * For example, if `decimals` equals `2`, a balance of `505` tokens should |
| 67 | * be displayed to a user as `5.05` (`505 / 10 ** 2`). |
| 68 | * |
| 69 | * Tokens usually opt for a value of 18, imitating the relationship between |
| 70 | * Ether and Wei. This is the default value returned by this function, unless |
| 71 | * it's overridden. |
| 72 | * |
| 73 | * NOTE: This information is only used for _display_ purposes: it in |
| 74 | * no way affects any of the arithmetic of the contract, including |
| 75 | * {IERC20-balanceOf} and {IERC20-transfer}. |
| 76 | */ |
| 77 | function decimals() public view virtual returns (uint8) { |
| 78 | return 18; |
| 79 | } |
| 80 | |
| 81 | /// @inheritdoc IERC20 |
| 82 | function totalSupply() public view virtual returns (uint256) { |
| 83 | return _totalSupply; |
| 84 | } |
| 85 | |
| 86 | /// @inheritdoc IERC20 |
| 87 | function balanceOf(address account) public view virtual returns (uint256) { |
| 88 | return _balances[account]; |
| 89 | } |
| 90 | |
| 91 | /** |
| 92 | * @dev See {IERC20-transfer}. |
| 93 | * |
| 94 | * Requirements: |
| 95 | * |
| 96 | * - `to` cannot be the zero address. |
| 97 | * - the caller must have a balance of at least `value`. |
| 98 | */ |
| 99 | function transfer(address to, uint256 value) public virtual returns (bool) { |
| 100 | address owner = _msgSender(); |
| 101 | _transfer(owner, to, value); |
| 102 | return true; |
| 103 | } |
| 104 | |
| 105 | /// @inheritdoc IERC20 |
| 106 | function allowance(address owner, address spender) public view virtual returns (uint256) { |
| 107 | return _allowances[owner][spender]; |
| 108 | } |
| 109 | |
| 110 | /** |
| 111 | * @dev See {IERC20-approve}. |
| 112 | * |
| 113 | * NOTE: If `value` is the maximum `uint256`, the allowance is not updated on |
| 114 | * `transferFrom`. This is semantically equivalent to an infinite approval. |
| 115 | * |
| 116 | * Requirements: |
| 117 | * |
| 118 | * - `spender` cannot be the zero address. |
| 119 | */ |
| 120 | function approve(address spender, uint256 value) public virtual returns (bool) { |
| 121 | address owner = _msgSender(); |
| 122 | _approve(owner, spender, value); |
| 123 | return true; |
| 124 | } |
| 125 | |
| 126 | /** |
| 127 | * @dev See {IERC20-transferFrom}. |
| 128 | * |
| 129 | * Skips emitting an {Approval} event indicating an allowance update. This is not |
| 130 | * required by the ERC. See {xref-ERC20-_approve-address-address-uint256-bool-}[_approve]. |
| 131 | * |
| 132 | * NOTE: Does not update the allowance if the current allowance |
| 133 | * is the maximum `uint256`. |
| 134 | * |
| 135 | * Requirements: |
| 136 | * |
| 137 | * - `from` and `to` cannot be the zero address. |
| 138 | * - `from` must have a balance of at least `value`. |
| 139 | * - the caller must have allowance for ``from``'s tokens of at least |
| 140 | * `value`. |
| 141 | */ |
| 142 | function transferFrom(address from, address to, uint256 value) public virtual returns (bool) { |
| 143 | address spender = _msgSender(); |
| 144 | _spendAllowance(from, spender, value); |
| 145 | _transfer(from, to, value); |
| 146 | return true; |
| 147 | } |
| 148 | |
| 149 | /** |
| 150 | * @dev Moves a `value` amount of tokens from `from` to `to`. |
| 151 | * |
| 152 | * This internal function is equivalent to {transfer}, and can be used to |
| 153 | * e.g. implement automatic token fees, slashing mechanisms, etc. |
| 154 | * |
| 155 | * Emits a {Transfer} event. |
| 156 | * |
| 157 | * NOTE: This function is not virtual, {_update} should be overridden instead. |
| 158 | */ |
| 159 | function _transfer(address from, address to, uint256 value) internal { |
| 160 | if (from == address(0)) { |
| 161 | revert ERC20InvalidSender(address(0)); |
| 162 | } |
| 163 | if (to == address(0)) { |
| 164 | revert ERC20InvalidReceiver(address(0)); |
| 165 | } |
| 166 | _update(from, to, value); |
| 167 | } |
| 168 | |
| 169 | /** |
| 170 | * @dev Transfers a `value` amount of tokens from `from` to `to`, or alternatively mints (or burns) if `from` |
| 171 | * (or `to`) is the zero address. All customizations to transfers, mints, and burns should be done by overriding |
| 172 | * this function. |
| 173 | * |
| 174 | * Emits a {Transfer} event. |
| 175 | */ |
| 176 | function _update(address from, address to, uint256 value) internal virtual { |
| 177 | if (from == address(0)) { |
| 178 | // Overflow check required: The rest of the code assumes that totalSupply never overflows |
| 179 | _totalSupply += value; |
| 180 | } else { |
| 181 | uint256 fromBalance = _balances[from]; |
| 182 | if (fromBalance < value) { |
| 183 | revert ERC20InsufficientBalance(from, fromBalance, value); |
| 184 | } |
| 185 | unchecked { |
| 186 | // Overflow not possible: value <= fromBalance <= totalSupply. |
| 187 | _balances[from] = fromBalance - value; |
| 188 | } |
| 189 | } |
| 190 | |
| 191 | if (to == address(0)) { |
| 192 | unchecked { |
| 193 | // Overflow not possible: value <= totalSupply or value <= fromBalance <= totalSupply. |
| 194 | _totalSupply -= value; |
| 195 | } |
| 196 | } else { |
| 197 | unchecked { |
| 198 | // Overflow not possible: balance + value is at most totalSupply, which we know fits into a uint256. |
| 199 | _balances[to] += value; |
| 200 | } |
| 201 | } |
| 202 | |
| 203 | emit Transfer(from, to, value); |
| 204 | } |
| 205 | |
| 206 | /** |
| 207 | * @dev Creates a `value` amount of tokens and assigns them to `account`, by transferring it from address(0). |
| 208 | * Relies on the `_update` mechanism |
| 209 | * |
| 210 | * Emits a {Transfer} event with `from` set to the zero address. |
| 211 | * |
| 212 | * NOTE: This function is not virtual, {_update} should be overridden instead. |
| 213 | */ |
| 214 | function _mint(address account, uint256 value) internal { |
| 215 | if (account == address(0)) { |
| 216 | revert ERC20InvalidReceiver(address(0)); |
| 217 | } |
| 218 | _update(address(0), account, value); |
| 219 | } |
| 220 | |
| 221 | /** |
| 222 | * @dev Destroys a `value` amount of tokens from `account`, lowering the total supply. |
| 223 | * Relies on the `_update` mechanism. |
| 224 | * |
| 225 | * Emits a {Transfer} event with `to` set to the zero address. |
| 226 | * |
| 227 | * NOTE: This function is not virtual, {_update} should be overridden instead |
| 228 | */ |
| 229 | function _burn(address account, uint256 value) internal { |
| 230 | if (account == address(0)) { |
| 231 | revert ERC20InvalidSender(address(0)); |
| 232 | } |
| 233 | _update(account, address(0), value); |
| 234 | } |
| 235 | |
| 236 | /** |
| 237 | * @dev Sets `value` as the allowance of `spender` over the `owner`'s tokens. |
| 238 | * |
| 239 | * This internal function is equivalent to `approve`, and can be used to |
| 240 | * e.g. set automatic allowances for certain subsystems, etc. |
| 241 | * |
| 242 | * Emits an {Approval} event. |
| 243 | * |
| 244 | * Requirements: |
| 245 | * |
| 246 | * - `owner` cannot be the zero address. |
| 247 | * - `spender` cannot be the zero address. |
| 248 | * |
| 249 | * Overrides to this logic should be done to the variant with an additional `bool emitEvent` argument. |
| 250 | */ |
| 251 | function _approve(address owner, address spender, uint256 value) internal { |
| 252 | _approve(owner, spender, value, true); |
| 253 | } |
| 254 | |
| 255 | /** |
| 256 | * @dev Variant of {_approve} with an optional flag to enable or disable the {Approval} event. |
| 257 | * |
| 258 | * By default (when calling {_approve}) the flag is set to true. On the other hand, approval changes made by |
| 259 | * `_spendAllowance` during the `transferFrom` operation sets the flag to false. This saves gas by not emitting any |
| 260 | * `Approval` event during `transferFrom` operations. |
| 261 | * |
| 262 | * Anyone who wishes to continue emitting `Approval` events on the `transferFrom` operation can force the flag to |
| 263 | * true using the following override: |
| 264 | * |
| 265 | * ```solidity |
| 266 | * function _approve(address owner, address spender, uint256 value, bool) internal virtual override { |
| 267 | * super._approve(owner, spender, value, true); |
| 268 | * } |
| 269 | * ``` |
| 270 | * |
| 271 | * Requirements are the same as {_approve}. |
| 272 | */ |
| 273 | function _approve(address owner, address spender, uint256 value, bool emitEvent) internal virtual { |
| 274 | if (owner == address(0)) { |
| 275 | revert ERC20InvalidApprover(address(0)); |
| 276 | } |
| 277 | if (spender == address(0)) { |
| 278 | revert ERC20InvalidSpender(address(0)); |
| 279 | } |
| 280 | _allowances[owner][spender] = value; |
| 281 | if (emitEvent) { |
| 282 | emit Approval(owner, spender, value); |
| 283 | } |
| 284 | } |
| 285 | |
| 286 | /** |
| 287 | * @dev Updates `owner`'s allowance for `spender` based on spent `value`. |
| 288 | * |
| 289 | * Does not update the allowance value in case of infinite allowance. |
| 290 | * Revert if not enough allowance is available. |
| 291 | * |
| 292 | * Does not emit an {Approval} event. |
| 293 | */ |
| 294 | function _spendAllowance(address owner, address spender, uint256 value) internal virtual { |
| 295 | uint256 currentAllowance = allowance(owner, spender); |
| 296 | if (currentAllowance < type(uint256).max) { |
| 297 | if (currentAllowance < value) { |
| 298 | revert ERC20InsufficientAllowance(spender, currentAllowance, value); |
| 299 | } |
| 300 | unchecked { |
| 301 | _approve(owner, spender, currentAllowance - value, false); |
| 302 | } |
| 303 | } |
| 304 | } |
| 305 | } |
| 306 |
0.0%
lib/openzeppelin-contracts/contracts/token/ERC20/IERC20.sol
Lines covered: 0 / 0 (0.0%)
| 1 | // SPDX-License-Identifier: MIT |
| 2 | // OpenZeppelin Contracts (last updated v5.4.0) (token/ERC20/IERC20.sol) |
| 3 | |
| 4 | pragma solidity >=0.4.16; |
| 5 | |
| 6 | /** |
| 7 | * @dev Interface of the ERC-20 standard as defined in the ERC. |
| 8 | */ |
| 9 | interface IERC20 { |
| 10 | /** |
| 11 | * @dev Emitted when `value` tokens are moved from one account (`from`) to |
| 12 | * another (`to`). |
| 13 | * |
| 14 | * Note that `value` may be zero. |
| 15 | */ |
| 16 | event Transfer(address indexed from, address indexed to, uint256 value); |
| 17 | |
| 18 | /** |
| 19 | * @dev Emitted when the allowance of a `spender` for an `owner` is set by |
| 20 | * a call to {approve}. `value` is the new allowance. |
| 21 | */ |
| 22 | event Approval(address indexed owner, address indexed spender, uint256 value); |
| 23 | |
| 24 | /** |
| 25 | * @dev Returns the value of tokens in existence. |
| 26 | */ |
| 27 | function totalSupply() external view returns (uint256); |
| 28 | |
| 29 | /** |
| 30 | * @dev Returns the value of tokens owned by `account`. |
| 31 | */ |
| 32 | function balanceOf(address account) external view returns (uint256); |
| 33 | |
| 34 | /** |
| 35 | * @dev Moves a `value` amount of tokens from the caller's account to `to`. |
| 36 | * |
| 37 | * Returns a boolean value indicating whether the operation succeeded. |
| 38 | * |
| 39 | * Emits a {Transfer} event. |
| 40 | */ |
| 41 | function transfer(address to, uint256 value) external returns (bool); |
| 42 | |
| 43 | /** |
| 44 | * @dev Returns the remaining number of tokens that `spender` will be |
| 45 | * allowed to spend on behalf of `owner` through {transferFrom}. This is |
| 46 | * zero by default. |
| 47 | * |
| 48 | * This value changes when {approve} or {transferFrom} are called. |
| 49 | */ |
| 50 | function allowance(address owner, address spender) external view returns (uint256); |
| 51 | |
| 52 | /** |
| 53 | * @dev Sets a `value` amount of tokens as the allowance of `spender` over the |
| 54 | * caller's tokens. |
| 55 | * |
| 56 | * Returns a boolean value indicating whether the operation succeeded. |
| 57 | * |
| 58 | * IMPORTANT: Beware that changing an allowance with this method brings the risk |
| 59 | * that someone may use both the old and the new allowance by unfortunate |
| 60 | * transaction ordering. One possible solution to mitigate this race |
| 61 | * condition is to first reduce the spender's allowance to 0 and set the |
| 62 | * desired value afterwards: |
| 63 | * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729 |
| 64 | * |
| 65 | * Emits an {Approval} event. |
| 66 | */ |
| 67 | function approve(address spender, uint256 value) external returns (bool); |
| 68 | |
| 69 | /** |
| 70 | * @dev Moves a `value` amount of tokens from `from` to `to` using the |
| 71 | * allowance mechanism. `value` is then deducted from the caller's |
| 72 | * allowance. |
| 73 | * |
| 74 | * Returns a boolean value indicating whether the operation succeeded. |
| 75 | * |
| 76 | * Emits a {Transfer} event. |
| 77 | */ |
| 78 | function transferFrom(address from, address to, uint256 value) external returns (bool); |
| 79 | } |
| 80 |
0.0%
lib/openzeppelin-contracts/contracts/token/ERC20/extensions/IERC20Metadata.sol
Lines covered: 0 / 0 (0.0%)
| 1 | // SPDX-License-Identifier: MIT |
| 2 | // OpenZeppelin Contracts (last updated v5.4.0) (token/ERC20/extensions/IERC20Metadata.sol) |
| 3 | |
| 4 | pragma solidity >=0.6.2; |
| 5 | |
| 6 | import {IERC20} from "../IERC20.sol"; |
| 7 | |
| 8 | /** |
| 9 | * @dev Interface for the optional metadata functions from the ERC-20 standard. |
| 10 | */ |
| 11 | interface IERC20Metadata is IERC20 { |
| 12 | /** |
| 13 | * @dev Returns the name of the token. |
| 14 | */ |
| 15 | function name() external view returns (string memory); |
| 16 | |
| 17 | /** |
| 18 | * @dev Returns the symbol of the token. |
| 19 | */ |
| 20 | function symbol() external view returns (string memory); |
| 21 | |
| 22 | /** |
| 23 | * @dev Returns the decimals places of the token. |
| 24 | */ |
| 25 | function decimals() external view returns (uint8); |
| 26 | } |
| 27 |
10.0%
lib/openzeppelin-contracts/contracts/token/ERC20/utils/SafeERC20.sol
Lines covered: 1 / 10 (10.0%)
| 1 | // SPDX-License-Identifier: MIT |
| 2 | // OpenZeppelin Contracts (last updated v5.5.0) (token/ERC20/utils/SafeERC20.sol) |
| 3 | |
| 4 | pragma solidity ^0.8.20; |
| 5 | |
| 6 | import {IERC20} from "../IERC20.sol"; |
| 7 | import {IERC1363} from "../../../interfaces/IERC1363.sol"; |
| 8 | |
| 9 | /** |
| 10 | * @title SafeERC20 |
| 11 | * @dev Wrappers around ERC-20 operations that throw on failure (when the token |
| 12 | * contract returns false). Tokens that return no value (and instead revert or |
| 13 | * throw on failure) are also supported, non-reverting calls are assumed to be |
| 14 | * successful. |
| 15 | * To use this library you can add a `using SafeERC20 for IERC20;` statement to your contract, |
| 16 | * which allows you to call the safe operations as `token.safeTransfer(...)`, etc. |
| 17 | */ |
| 18 | library SafeERC20 { |
| 19 | /** |
| 20 | * @dev An operation with an ERC-20 token failed. |
| 21 | */ |
| 22 | error SafeERC20FailedOperation(address token); |
| 23 | |
| 24 | /** |
| 25 | * @dev Indicates a failed `decreaseAllowance` request. |
| 26 | */ |
| 27 | error SafeERC20FailedDecreaseAllowance(address spender, uint256 currentAllowance, uint256 requestedDecrease); |
| 28 | |
| 29 | /** |
| 30 | * @dev Transfer `value` amount of `token` from the calling contract to `to`. If `token` returns no value, |
| 31 | * non-reverting calls are assumed to be successful. |
| 32 | */ |
| 33 | function safeTransfer(IERC20 token, address to, uint256 value) internal { |
| 34 | if (!_safeTransfer(token, to, value, true)) { |
| 35 | revert SafeERC20FailedOperation(address(token)); |
| 36 | } |
| 37 | } |
| 38 | |
| 39 | /** |
| 40 | * @dev Transfer `value` amount of `token` from `from` to `to`, spending the approval given by `from` to the |
| 41 | * calling contract. If `token` returns no value, non-reverting calls are assumed to be successful. |
| 42 | */ |
| 43 | function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal { |
| 44 | if (!_safeTransferFrom(token, from, to, value, true)) { |
| 45 | revert SafeERC20FailedOperation(address(token)); |
| 46 | } |
| 47 | } |
| 48 | |
| 49 | /** |
| 50 | * @dev Variant of {safeTransfer} that returns a bool instead of reverting if the operation is not successful. |
| 51 | */ |
| 52 | function trySafeTransfer(IERC20 token, address to, uint256 value) internal returns (bool) { |
| 53 | return _safeTransfer(token, to, value, false); |
| 54 | } |
| 55 | |
| 56 | /** |
| 57 | * @dev Variant of {safeTransferFrom} that returns a bool instead of reverting if the operation is not successful. |
| 58 | */ |
| 59 | function trySafeTransferFrom(IERC20 token, address from, address to, uint256 value) internal returns (bool) { |
| 60 | return _safeTransferFrom(token, from, to, value, false); |
| 61 | } |
| 62 | |
| 63 | /** |
| 64 | * @dev Increase the calling contract's allowance toward `spender` by `value`. If `token` returns no value, |
| 65 | * non-reverting calls are assumed to be successful. |
| 66 | * |
| 67 | * IMPORTANT: If the token implements ERC-7674 (ERC-20 with temporary allowance), and if the "client" |
| 68 | * smart contract uses ERC-7674 to set temporary allowances, then the "client" smart contract should avoid using |
| 69 | * this function. Performing a {safeIncreaseAllowance} or {safeDecreaseAllowance} operation on a token contract |
| 70 | * that has a non-zero temporary allowance (for that particular owner-spender) will result in unexpected behavior. |
| 71 | */ |
| 72 | function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal { |
| 73 | uint256 oldAllowance = token.allowance(address(this), spender); |
| 74 | forceApprove(token, spender, oldAllowance + value); |
| 75 | } |
| 76 | |
| 77 | /** |
| 78 | * @dev Decrease the calling contract's allowance toward `spender` by `requestedDecrease`. If `token` returns no |
| 79 | * value, non-reverting calls are assumed to be successful. |
| 80 | * |
| 81 | * IMPORTANT: If the token implements ERC-7674 (ERC-20 with temporary allowance), and if the "client" |
| 82 | * smart contract uses ERC-7674 to set temporary allowances, then the "client" smart contract should avoid using |
| 83 | * this function. Performing a {safeIncreaseAllowance} or {safeDecreaseAllowance} operation on a token contract |
| 84 | * that has a non-zero temporary allowance (for that particular owner-spender) will result in unexpected behavior. |
| 85 | */ |
| 86 | function safeDecreaseAllowance(IERC20 token, address spender, uint256 requestedDecrease) internal { |
| 87 | unchecked { |
| 88 | uint256 currentAllowance = token.allowance(address(this), spender); |
| 89 | if (currentAllowance < requestedDecrease) { |
| 90 | revert SafeERC20FailedDecreaseAllowance(spender, currentAllowance, requestedDecrease); |
| 91 | } |
| 92 | forceApprove(token, spender, currentAllowance - requestedDecrease); |
| 93 | } |
| 94 | } |
| 95 | |
| 96 | /** |
| 97 | * @dev Set the calling contract's allowance toward `spender` to `value`. If `token` returns no value, |
| 98 | * non-reverting calls are assumed to be successful. Meant to be used with tokens that require the approval |
| 99 | * to be set to zero before setting it to a non-zero value, such as USDT. |
| 100 | * |
| 101 | * NOTE: If the token implements ERC-7674, this function will not modify any temporary allowance. This function |
| 102 | * only sets the "standard" allowance. Any temporary allowance will remain active, in addition to the value being |
| 103 | * set here. |
| 104 | */ |
| 105 | function forceApprove(IERC20 token, address spender, uint256 value) internal { |
| 106 | if (!_safeApprove(token, spender, value, false)) { |
| 107 | if (!_safeApprove(token, spender, 0, true)) revert SafeERC20FailedOperation(address(token)); |
| 108 | if (!_safeApprove(token, spender, value, true)) revert SafeERC20FailedOperation(address(token)); |
| 109 | } |
| 110 | } |
| 111 | |
| 112 | /** |
| 113 | * @dev Performs an {ERC1363} transferAndCall, with a fallback to the simple {ERC20} transfer if the target has no |
| 114 | * code. This can be used to implement an {ERC721}-like safe transfer that relies on {ERC1363} checks when |
| 115 | * targeting contracts. |
| 116 | * |
| 117 | * Reverts if the returned value is other than `true`. |
| 118 | */ |
| 119 | function transferAndCallRelaxed(IERC1363 token, address to, uint256 value, bytes memory data) internal { |
| 120 | if (to.code.length == 0) { |
| 121 | safeTransfer(token, to, value); |
| 122 | } else if (!token.transferAndCall(to, value, data)) { |
| 123 | revert SafeERC20FailedOperation(address(token)); |
| 124 | } |
| 125 | } |
| 126 | |
| 127 | /** |
| 128 | * @dev Performs an {ERC1363} transferFromAndCall, with a fallback to the simple {ERC20} transferFrom if the target |
| 129 | * has no code. This can be used to implement an {ERC721}-like safe transfer that relies on {ERC1363} checks when |
| 130 | * targeting contracts. |
| 131 | * |
| 132 | * Reverts if the returned value is other than `true`. |
| 133 | */ |
| 134 | function transferFromAndCallRelaxed( |
| 135 | IERC1363 token, |
| 136 | address from, |
| 137 | address to, |
| 138 | uint256 value, |
| 139 | bytes memory data |
| 140 | ) internal { |
| 141 | if (to.code.length == 0) { |
| 142 | safeTransferFrom(token, from, to, value); |
| 143 | } else if (!token.transferFromAndCall(from, to, value, data)) { |
| 144 | revert SafeERC20FailedOperation(address(token)); |
| 145 | } |
| 146 | } |
| 147 | |
| 148 | /** |
| 149 | * @dev Performs an {ERC1363} approveAndCall, with a fallback to the simple {ERC20} approve if the target has no |
| 150 | * code. This can be used to implement an {ERC721}-like safe transfer that rely on {ERC1363} checks when |
| 151 | * targeting contracts. |
| 152 | * |
| 153 | * NOTE: When the recipient address (`to`) has no code (i.e. is an EOA), this function behaves as {forceApprove}. |
| 154 | * Oppositely, when the recipient address (`to`) has code, this function only attempts to call {ERC1363-approveAndCall} |
| 155 | * once without retrying, and relies on the returned value to be true. |
| 156 | * |
| 157 | * Reverts if the returned value is other than `true`. |
| 158 | */ |
| 159 | function approveAndCallRelaxed(IERC1363 token, address to, uint256 value, bytes memory data) internal { |
| 160 | if (to.code.length == 0) { |
| 161 | forceApprove(token, to, value); |
| 162 | } else if (!token.approveAndCall(to, value, data)) { |
| 163 | revert SafeERC20FailedOperation(address(token)); |
| 164 | } |
| 165 | } |
| 166 | |
| 167 | /** |
| 168 | * @dev Imitates a Solidity `token.transfer(to, value)` call, relaxing the requirement on the return value: the |
| 169 | * return value is optional (but if data is returned, it must not be false). |
| 170 | * |
| 171 | * @param token The token targeted by the call. |
| 172 | * @param to The recipient of the tokens |
| 173 | * @param value The amount of token to transfer |
| 174 | * @param bubble Behavior switch if the transfer call reverts: bubble the revert reason or return a false boolean. |
| 175 | */ |
| 176 | function _safeTransfer(IERC20 token, address to, uint256 value, bool bubble) private returns (bool success) { |
| 177 | bytes4 selector = IERC20.transfer.selector; |
| 178 | |
| 179 | assembly ("memory-safe") { |
| 180 | let fmp := mload(0x40) |
| 181 | mstore(0x00, selector) |
| 182 | mstore(0x04, and(to, shr(96, not(0)))) |
| 183 | mstore(0x24, value) |
| 184 | success := call(gas(), token, 0, 0x00, 0x44, 0x00, 0x20) |
| 185 | // if call success and return is true, all is good. |
| 186 | // otherwise (not success or return is not true), we need to perform further checks |
| 187 | if iszero(and(success, eq(mload(0x00), 1))) { |
| 188 | // if the call was a failure and bubble is enabled, bubble the error |
| 189 | if and(iszero(success), bubble) { |
| 190 | returndatacopy(fmp, 0x00, returndatasize()) |
| 191 | revert(fmp, returndatasize()) |
| 192 | } |
| 193 | // if the return value is not true, then the call is only successful if: |
| 194 | // - the token address has code |
| 195 | // - the returndata is empty |
| 196 | success := and(success, and(iszero(returndatasize()), gt(extcodesize(token), 0))) |
| 197 | } |
| 198 | mstore(0x40, fmp) |
| 199 | } |
| 200 | } |
| 201 | |
| 202 | /** |
| 203 | * @dev Imitates a Solidity `token.transferFrom(from, to, value)` call, relaxing the requirement on the return |
| 204 | * value: the return value is optional (but if data is returned, it must not be false). |
| 205 | * |
| 206 | * @param token The token targeted by the call. |
| 207 | * @param from The sender of the tokens |
| 208 | * @param to The recipient of the tokens |
| 209 | * @param value The amount of token to transfer |
| 210 | * @param bubble Behavior switch if the transfer call reverts: bubble the revert reason or return a false boolean. |
| 211 | */ |
| 212 | function _safeTransferFrom( |
| 213 | IERC20 token, |
| 214 | address from, |
| 215 | address to, |
| 216 | uint256 value, |
| 217 | bool bubble |
| 218 | ) private returns (bool success) { |
| 219 | bytes4 selector = IERC20.transferFrom.selector; |
| 220 | |
| 221 | assembly ("memory-safe") { |
| 222 | let fmp := mload(0x40) |
| 223 | mstore(0x00, selector) |
| 224 | mstore(0x04, and(from, shr(96, not(0)))) |
| 225 | mstore(0x24, and(to, shr(96, not(0)))) |
| 226 | mstore(0x44, value) |
| 227 | success := call(gas(), token, 0, 0x00, 0x64, 0x00, 0x20) |
| 228 | // if call success and return is true, all is good. |
| 229 | // otherwise (not success or return is not true), we need to perform further checks |
| 230 | if iszero(and(success, eq(mload(0x00), 1))) { |
| 231 | // if the call was a failure and bubble is enabled, bubble the error |
| 232 | if and(iszero(success), bubble) { |
| 233 | returndatacopy(fmp, 0x00, returndatasize()) |
| 234 | revert(fmp, returndatasize()) |
| 235 | } |
| 236 | // if the return value is not true, then the call is only successful if: |
| 237 | // - the token address has code |
| 238 | // - the returndata is empty |
| 239 | success := and(success, and(iszero(returndatasize()), gt(extcodesize(token), 0))) |
| 240 | } |
| 241 | mstore(0x40, fmp) |
| 242 | mstore(0x60, 0) |
| 243 | } |
| 244 | } |
| 245 | |
| 246 | /** |
| 247 | * @dev Imitates a Solidity `token.approve(spender, value)` call, relaxing the requirement on the return value: |
| 248 | * the return value is optional (but if data is returned, it must not be false). |
| 249 | * |
| 250 | * @param token The token targeted by the call. |
| 251 | * @param spender The spender of the tokens |
| 252 | * @param value The amount of token to transfer |
| 253 | * @param bubble Behavior switch if the transfer call reverts: bubble the revert reason or return a false boolean. |
| 254 | */ |
| 255 | function _safeApprove(IERC20 token, address spender, uint256 value, bool bubble) private returns (bool success) { |
| 256 | bytes4 selector = IERC20.approve.selector; |
| 257 | |
| 258 | assembly ("memory-safe") { |
| 259 | let fmp := mload(0x40) |
| 260 | mstore(0x00, selector) |
| 261 | mstore(0x04, and(spender, shr(96, not(0)))) |
| 262 | mstore(0x24, value) |
| 263 | success := call(gas(), token, 0, 0x00, 0x44, 0x00, 0x20) |
| 264 | // if call success and return is true, all is good. |
| 265 | // otherwise (not success or return is not true), we need to perform further checks |
| 266 | if iszero(and(success, eq(mload(0x00), 1))) { |
| 267 | // if the call was a failure and bubble is enabled, bubble the error |
| 268 | if and(iszero(success), bubble) { |
| 269 | returndatacopy(fmp, 0x00, returndatasize()) |
| 270 | revert(fmp, returndatasize()) |
| 271 | } |
| 272 | // if the return value is not true, then the call is only successful if: |
| 273 | // - the token address has code |
| 274 | // - the returndata is empty |
| 275 | success := and(success, and(iszero(returndatasize()), gt(extcodesize(token), 0))) |
| 276 | } |
| 277 | mstore(0x40, fmp) |
| 278 | } |
| 279 | } |
| 280 | } |
| 281 |
100.0%
lib/openzeppelin-contracts/contracts/utils/Context.sol
Lines covered: 1 / 1 (100.0%)
| 1 | // SPDX-License-Identifier: MIT |
| 2 | // OpenZeppelin Contracts (last updated v5.0.1) (utils/Context.sol) |
| 3 | |
| 4 | pragma solidity ^0.8.20; |
| 5 | |
| 6 | /** |
| 7 | * @dev Provides information about the current execution context, including the |
| 8 | * sender of the transaction and its data. While these are generally available |
| 9 | * via msg.sender and msg.data, they should not be accessed in such a direct |
| 10 | * manner, since when dealing with meta-transactions the account sending and |
| 11 | * paying for execution may not be the actual sender (as far as an application |
| 12 | * is concerned). |
| 13 | * |
| 14 | * This contract is only required for intermediate, library-like contracts. |
| 15 | */ |
| 16 | abstract contract Context { |
| 17 | function _msgSender() internal view virtual returns (address) { |
| 18 | return msg.sender; |
| 19 | } |
| 20 | |
| 21 | function _msgData() internal view virtual returns (bytes calldata) { |
| 22 | return msg.data; |
| 23 | } |
| 24 | |
| 25 | function _contextSuffixLength() internal view virtual returns (uint256) { |
| 26 | return 0; |
| 27 | } |
| 28 | } |
| 29 |
14.0%
lib/openzeppelin-contracts/contracts/utils/ReentrancyGuard.sol
Lines covered: 1 / 7 (14.0%)
| 1 | // SPDX-License-Identifier: MIT |
| 2 | // OpenZeppelin Contracts (last updated v5.5.0) (utils/ReentrancyGuard.sol) |
| 3 | |
| 4 | pragma solidity ^0.8.20; |
| 5 | |
| 6 | import {StorageSlot} from "./StorageSlot.sol"; |
| 7 | |
| 8 | /** |
| 9 | * @dev Contract module that helps prevent reentrant calls to a function. |
| 10 | * |
| 11 | * Inheriting from `ReentrancyGuard` will make the {nonReentrant} modifier |
| 12 | * available, which can be applied to functions to make sure there are no nested |
| 13 | * (reentrant) calls to them. |
| 14 | * |
| 15 | * Note that because there is a single `nonReentrant` guard, functions marked as |
| 16 | * `nonReentrant` may not call one another. This can be worked around by making |
| 17 | * those functions `private`, and then adding `external` `nonReentrant` entry |
| 18 | * points to them. |
| 19 | * |
| 20 | * TIP: If EIP-1153 (transient storage) is available on the chain you're deploying at, |
| 21 | * consider using {ReentrancyGuardTransient} instead. |
| 22 | * |
| 23 | * TIP: If you would like to learn more about reentrancy and alternative ways |
| 24 | * to protect against it, check out our blog post |
| 25 | * https://blog.openzeppelin.com/reentrancy-after-istanbul/[Reentrancy After Istanbul]. |
| 26 | * |
| 27 | * IMPORTANT: Deprecated. This storage-based reentrancy guard will be removed and replaced |
| 28 | * by the {ReentrancyGuardTransient} variant in v6.0. |
| 29 | * |
| 30 | * @custom:stateless |
| 31 | */ |
| 32 | abstract contract ReentrancyGuard { |
| 33 | using StorageSlot for bytes32; |
| 34 | |
| 35 | // keccak256(abi.encode(uint256(keccak256("openzeppelin.storage.ReentrancyGuard")) - 1)) & ~bytes32(uint256(0xff)) |
| 36 | bytes32 private constant REENTRANCY_GUARD_STORAGE = |
| 37 | 0x9b779b17422d0df92223018b32b4d1fa46e071723d6817e2486d003becc55f00; |
| 38 | |
| 39 | // Booleans are more expensive than uint256 or any type that takes up a full |
| 40 | // word because each write operation emits an extra SLOAD to first read the |
| 41 | // slot's contents, replace the bits taken up by the boolean, and then write |
| 42 | // back. This is the compiler's defense against contract upgrades and |
| 43 | // pointer aliasing, and it cannot be disabled. |
| 44 | |
| 45 | // The values being non-zero value makes deployment a bit more expensive, |
| 46 | // but in exchange the refund on every call to nonReentrant will be lower in |
| 47 | // amount. Since refunds are capped to a percentage of the total |
| 48 | // transaction's gas, it is best to keep them low in cases like this one, to |
| 49 | // increase the likelihood of the full refund coming into effect. |
| 50 | uint256 private constant NOT_ENTERED = 1; |
| 51 | uint256 private constant ENTERED = 2; |
| 52 | |
| 53 | /** |
| 54 | * @dev Unauthorized reentrant call. |
| 55 | */ |
| 56 | error ReentrancyGuardReentrantCall(); |
| 57 | |
| 58 | constructor() { |
| 59 | _reentrancyGuardStorageSlot().getUint256Slot().value = NOT_ENTERED; |
| 60 | } |
| 61 | |
| 62 | /** |
| 63 | * @dev Prevents a contract from calling itself, directly or indirectly. |
| 64 | * Calling a `nonReentrant` function from another `nonReentrant` |
| 65 | * function is not supported. It is possible to prevent this from happening |
| 66 | * by making the `nonReentrant` function external, and making it call a |
| 67 | * `private` function that does the actual work. |
| 68 | */ |
| 69 | modifier nonReentrant() { |
| 70 | _nonReentrantBefore(); |
| 71 | _; |
| 72 | _nonReentrantAfter(); |
| 73 | } |
| 74 | |
| 75 | /** |
| 76 | * @dev A `view` only version of {nonReentrant}. Use to block view functions |
| 77 | * from being called, preventing reading from inconsistent contract state. |
| 78 | * |
| 79 | * CAUTION: This is a "view" modifier and does not change the reentrancy |
| 80 | * status. Use it only on view functions. For payable or non-payable functions, |
| 81 | * use the standard {nonReentrant} modifier instead. |
| 82 | */ |
| 83 | modifier nonReentrantView() { |
| 84 | _nonReentrantBeforeView(); |
| 85 | _; |
| 86 | } |
| 87 | |
| 88 | function _nonReentrantBeforeView() private view { |
| 89 | if (_reentrancyGuardEntered()) { |
| 90 | revert ReentrancyGuardReentrantCall(); |
| 91 | } |
| 92 | } |
| 93 | |
| 94 | function _nonReentrantBefore() private { |
| 95 | // On the first call to nonReentrant, _status will be NOT_ENTERED |
| 96 | _nonReentrantBeforeView(); |
| 97 | |
| 98 | // Any calls to nonReentrant after this point will fail |
| 99 | _reentrancyGuardStorageSlot().getUint256Slot().value = ENTERED; |
| 100 | } |
| 101 | |
| 102 | function _nonReentrantAfter() private { |
| 103 | // By storing the original value once again, a refund is triggered (see |
| 104 | // https://eips.ethereum.org/EIPS/eip-2200) |
| 105 | _reentrancyGuardStorageSlot().getUint256Slot().value = NOT_ENTERED; |
| 106 | } |
| 107 | |
| 108 | /** |
| 109 | * @dev Returns true if the reentrancy guard is currently set to "entered", which indicates there is a |
| 110 | * `nonReentrant` function in the call stack. |
| 111 | */ |
| 112 | function _reentrancyGuardEntered() internal view returns (bool) { |
| 113 | return _reentrancyGuardStorageSlot().getUint256Slot().value == ENTERED; |
| 114 | } |
| 115 | |
| 116 | function _reentrancyGuardStorageSlot() internal pure virtual returns (bytes32) { |
| 117 | return REENTRANCY_GUARD_STORAGE; |
| 118 | } |
| 119 | } |
| 120 |
0.0%
lib/openzeppelin-contracts/contracts/utils/StorageSlot.sol
Lines covered: 0 / 1 (0.0%)
| 1 | // SPDX-License-Identifier: MIT |
| 2 | // OpenZeppelin Contracts (last updated v5.1.0) (utils/StorageSlot.sol) |
| 3 | // This file was procedurally generated from scripts/generate/templates/StorageSlot.js. |
| 4 | |
| 5 | pragma solidity ^0.8.20; |
| 6 | |
| 7 | /** |
| 8 | * @dev Library for reading and writing primitive types to specific storage slots. |
| 9 | * |
| 10 | * Storage slots are often used to avoid storage conflict when dealing with upgradeable contracts. |
| 11 | * This library helps with reading and writing to such slots without the need for inline assembly. |
| 12 | * |
| 13 | * The functions in this library return Slot structs that contain a `value` member that can be used to read or write. |
| 14 | * |
| 15 | * Example usage to set ERC-1967 implementation slot: |
| 16 | * ```solidity |
| 17 | * contract ERC1967 { |
| 18 | * // Define the slot. Alternatively, use the SlotDerivation library to derive the slot. |
| 19 | * bytes32 internal constant _IMPLEMENTATION_SLOT = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc; |
| 20 | * |
| 21 | * function _getImplementation() internal view returns (address) { |
| 22 | * return StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value; |
| 23 | * } |
| 24 | * |
| 25 | * function _setImplementation(address newImplementation) internal { |
| 26 | * require(newImplementation.code.length > 0); |
| 27 | * StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value = newImplementation; |
| 28 | * } |
| 29 | * } |
| 30 | * ``` |
| 31 | * |
| 32 | * TIP: Consider using this library along with {SlotDerivation}. |
| 33 | */ |
| 34 | library StorageSlot { |
| 35 | struct AddressSlot { |
| 36 | address value; |
| 37 | } |
| 38 | |
| 39 | struct BooleanSlot { |
| 40 | bool value; |
| 41 | } |
| 42 | |
| 43 | struct Bytes32Slot { |
| 44 | bytes32 value; |
| 45 | } |
| 46 | |
| 47 | struct Uint256Slot { |
| 48 | uint256 value; |
| 49 | } |
| 50 | |
| 51 | struct Int256Slot { |
| 52 | int256 value; |
| 53 | } |
| 54 | |
| 55 | struct StringSlot { |
| 56 | string value; |
| 57 | } |
| 58 | |
| 59 | struct BytesSlot { |
| 60 | bytes value; |
| 61 | } |
| 62 | |
| 63 | /** |
| 64 | * @dev Returns an `AddressSlot` with member `value` located at `slot`. |
| 65 | */ |
| 66 | function getAddressSlot(bytes32 slot) internal pure returns (AddressSlot storage r) { |
| 67 | assembly ("memory-safe") { |
| 68 | r.slot := slot |
| 69 | } |
| 70 | } |
| 71 | |
| 72 | /** |
| 73 | * @dev Returns a `BooleanSlot` with member `value` located at `slot`. |
| 74 | */ |
| 75 | function getBooleanSlot(bytes32 slot) internal pure returns (BooleanSlot storage r) { |
| 76 | assembly ("memory-safe") { |
| 77 | r.slot := slot |
| 78 | } |
| 79 | } |
| 80 | |
| 81 | /** |
| 82 | * @dev Returns a `Bytes32Slot` with member `value` located at `slot`. |
| 83 | */ |
| 84 | function getBytes32Slot(bytes32 slot) internal pure returns (Bytes32Slot storage r) { |
| 85 | assembly ("memory-safe") { |
| 86 | r.slot := slot |
| 87 | } |
| 88 | } |
| 89 | |
| 90 | /** |
| 91 | * @dev Returns a `Uint256Slot` with member `value` located at `slot`. |
| 92 | */ |
| 93 | function getUint256Slot(bytes32 slot) internal pure returns (Uint256Slot storage r) { |
| 94 | assembly ("memory-safe") { |
| 95 | r.slot := slot |
| 96 | } |
| 97 | } |
| 98 | |
| 99 | /** |
| 100 | * @dev Returns a `Int256Slot` with member `value` located at `slot`. |
| 101 | */ |
| 102 | function getInt256Slot(bytes32 slot) internal pure returns (Int256Slot storage r) { |
| 103 | assembly ("memory-safe") { |
| 104 | r.slot := slot |
| 105 | } |
| 106 | } |
| 107 | |
| 108 | /** |
| 109 | * @dev Returns a `StringSlot` with member `value` located at `slot`. |
| 110 | */ |
| 111 | function getStringSlot(bytes32 slot) internal pure returns (StringSlot storage r) { |
| 112 | assembly ("memory-safe") { |
| 113 | r.slot := slot |
| 114 | } |
| 115 | } |
| 116 | |
| 117 | /** |
| 118 | * @dev Returns an `StringSlot` representation of the string storage pointer `store`. |
| 119 | */ |
| 120 | function getStringSlot(string storage store) internal pure returns (StringSlot storage r) { |
| 121 | assembly ("memory-safe") { |
| 122 | r.slot := store.slot |
| 123 | } |
| 124 | } |
| 125 | |
| 126 | /** |
| 127 | * @dev Returns a `BytesSlot` with member `value` located at `slot`. |
| 128 | */ |
| 129 | function getBytesSlot(bytes32 slot) internal pure returns (BytesSlot storage r) { |
| 130 | assembly ("memory-safe") { |
| 131 | r.slot := slot |
| 132 | } |
| 133 | } |
| 134 | |
| 135 | /** |
| 136 | * @dev Returns an `BytesSlot` representation of the bytes storage pointer `store`. |
| 137 | */ |
| 138 | function getBytesSlot(bytes storage store) internal pure returns (BytesSlot storage r) { |
| 139 | assembly ("memory-safe") { |
| 140 | r.slot := store.slot |
| 141 | } |
| 142 | } |
| 143 | } |
| 144 |
0.0%
lib/openzeppelin-contracts/contracts/utils/introspection/IERC165.sol
Lines covered: 0 / 0 (0.0%)
| 1 | // SPDX-License-Identifier: MIT |
| 2 | // OpenZeppelin Contracts (last updated v5.4.0) (utils/introspection/IERC165.sol) |
| 3 | |
| 4 | pragma solidity >=0.4.16; |
| 5 | |
| 6 | /** |
| 7 | * @dev Interface of the ERC-165 standard, as defined in the |
| 8 | * https://eips.ethereum.org/EIPS/eip-165[ERC]. |
| 9 | * |
| 10 | * Implementers can declare support of contract interfaces, which can then be |
| 11 | * queried by others ({ERC165Checker}). |
| 12 | * |
| 13 | * For an implementation, see {ERC165}. |
| 14 | */ |
| 15 | interface IERC165 { |
| 16 | /** |
| 17 | * @dev Returns true if this contract implements the interface defined by |
| 18 | * `interfaceId`. See the corresponding |
| 19 | * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[ERC section] |
| 20 | * to learn more about how these ids are created. |
| 21 | * |
| 22 | * This function call must use less than 30 000 gas. |
| 23 | */ |
| 24 | function supportsInterface(bytes4 interfaceId) external view returns (bool); |
| 25 | } |
| 26 |
57.0%
src/CreditPolicy.sol
Lines covered: 60 / 104 (57.0%)
| 1 | // SPDX-License-Identifier: MIT |
| 2 | pragma solidity ^0.8.24; |
| 3 | import {ICreditPolicy} from "./interfaces/ICreditPolicy.sol"; |
| 4 | |
| 5 | |
| 6 | /** |
| 7 | * @title CreditPolicy |
| 8 | * @notice Immutable-by-version credit constitution for private credit funds |
| 9 | */ |
| 10 | contract CreditPolicy is ICreditPolicy { |
| 11 | /*////////////////////////////////////////////////////////////// |
| 12 | ERRORS |
| 13 | //////////////////////////////////////////////////////////////*/ |
| 14 | error CreditPolicy__Unauthorized(); |
| 15 | error CreditPolicy__PolicyFrozen(uint256 version); |
| 16 | error CreditPolicy__InvalidVersion(); |
| 17 | error CreditPolicy__PolicyVersionExists(uint256 version); |
| 18 | error CreditPolicy__InvalidAdmin(); |
| 19 | error CreditPolicy__PolicyNotEditable(uint256 version); |
| 20 | error CreditPolicy__IncompletePolicy(uint256 version); |
| 21 | error CreditPolicy__InvalidIndustryHash(); |
| 22 | error CreditPolicy__PolicyNotActive(uint256 version); |
| 23 | error CreditPolicy__InvalidTierCount(uint256 count); |
| 24 | /*////////////////////////////////////////////////////////////// |
| 25 | MODIFIERS |
| 26 | //////////////////////////////////////////////////////////////*/ |
| 27 | modifier onlyAdmin() { |
| 28 | _onlyAdmin(); |
| 29 | _; |
| 30 | } |
| 31 | |
| 32 | function _onlyAdmin() internal view { |
| 33 | if (msg.sender != policyAdmin) revert CreditPolicy__Unauthorized(); |
| 34 | } |
| 35 | |
| 36 | modifier policyEditable(uint256 version) { |
| 37 | _policyEditable(version); |
| 38 | _; |
| 39 | } |
| 40 | |
| 41 | function _policyEditable(uint256 version) internal view { |
| 42 | if (policyFrozen[version] || !policyActive[version]) |
| 43 | revert CreditPolicy__PolicyNotEditable(version); |
| 44 | } |
| 45 | |
| 46 | modifier policyExists(uint256 version) { |
| 47 | _policyExists(version); |
| 48 | _; |
| 49 | } |
| 50 | |
| 51 | function _policyExists(uint256 version) internal view { |
| 52 | if (!policyCreated[version]) revert CreditPolicy__InvalidVersion(); |
| 53 | } |
| 54 | |
| 55 | /*////////////////////////////////////////////////////////////// |
| 56 | CORE ROLES |
| 57 | //////////////////////////////////////////////////////////////*/ |
| 58 | address public policyAdmin; |
| 59 | uint8 internal maxTiers; |
| 60 | |
| 61 | /*////////////////////////////////////////////////////////////// |
| 62 | POLICY LIFECYCLE |
| 63 | //////////////////////////////////////////////////////////////*/ |
| 64 | mapping(uint256 => bool) public policyCreated; |
| 65 | mapping(uint256 => bool) public policyFrozen; |
| 66 | mapping(uint256 => bool) public policyActive; |
| 67 | mapping(uint256 => uint256) public lastUpdated; |
| 68 | |
| 69 | /*////////////////////////////////////////////////////////////// |
| 70 | ELIGIBILITY (PRE-LOAN) |
| 71 | //////////////////////////////////////////////////////////////*/ |
| 72 | struct EligibilityCriteria { |
| 73 | uint256 minAnnualRevenue; |
| 74 | uint256 minEBITDA; |
| 75 | uint256 minTangibleNetWorth; |
| 76 | uint256 minBusinessAgeDays; |
| 77 | uint256 maxDefaultsLast36Months; |
| 78 | bool bankruptcyExcluded; |
| 79 | } |
| 80 | |
| 81 | mapping(uint256 => EligibilityCriteria) public eligibility; |
| 82 | |
| 83 | /*////////////////////////////////////////////////////////////// |
| 84 | FINANCIAL RATIOS (UNDERWRITING) |
| 85 | //////////////////////////////////////////////////////////////*/ |
| 86 | struct FinancialRatios { |
| 87 | uint256 maxTotalDebtToEBITDA; |
| 88 | uint256 minInterestCoverageRatio; |
| 89 | uint256 minCurrentRatio; |
| 90 | uint256 minEBITDAMarginBps; |
| 91 | } |
| 92 | |
| 93 | mapping(uint256 => FinancialRatios) public ratios; |
| 94 | |
| 95 | /*////////////////////////////////////////////////////////////// |
| 96 | LOAN TIERS (PRICING REFERENCE) |
| 97 | //////////////////////////////////////////////////////////////*/ |
| 98 | struct LoanTier { |
| 99 | string name; |
| 100 | uint256 minRevenue; |
| 101 | uint256 maxRevenue; |
| 102 | uint256 minEBITDA; |
| 103 | uint256 maxDebtToEBITDA; |
| 104 | uint256 maxLoanToEBITDA; |
| 105 | uint256 interestRateBps; |
| 106 | uint256 originationFeeBps; |
| 107 | uint256 termDays; |
| 108 | bool active; |
| 109 | } |
| 110 | |
| 111 | mapping(uint256 => mapping(uint8 => LoanTier)) public loanTiers; |
| 112 | mapping(uint256 => uint8) public totalTiers; |
| 113 | mapping(uint256 => mapping(uint8 => bool)) public tierExists; |
| 114 | |
| 115 | /*////////////////////////////////////////////////////////////// |
| 116 | CONCENTRATION LIMITS |
| 117 | //////////////////////////////////////////////////////////////*/ |
| 118 | struct ConcentrationLimits { |
| 119 | uint256 maxSingleBorrowerBps; |
| 120 | uint256 maxIndustryConcentrationBps; |
| 121 | } |
| 122 | |
| 123 | mapping(uint256 => ConcentrationLimits) public concentration; |
| 124 | |
| 125 | /*////////////////////////////////////////////////////////////// |
| 126 | INDUSTRY EXCLUSIONS |
| 127 | //////////////////////////////////////////////////////////////*/ |
| 128 | mapping(uint256 => mapping(bytes32 => bool)) public excludedIndustries; |
| 129 | |
| 130 | /*////////////////////////////////////////////////////////////// |
| 131 | ATTESTATION REQUIREMENTS |
| 132 | //////////////////////////////////////////////////////////////*/ |
| 133 | struct AttestationRequirements { |
| 134 | uint256 maxAttestationAgeDays; |
| 135 | uint256 reAttestationFrequencyDays; |
| 136 | bool requiresCPAAttestation; |
| 137 | } |
| 138 | |
| 139 | mapping(uint256 => AttestationRequirements) public attestation; |
| 140 | |
| 141 | /*////////////////////////////////////////////////////////////// |
| 142 | MAINTENANCE COVENANTS |
| 143 | //////////////////////////////////////////////////////////////*/ |
| 144 | struct MaintenanceCovenants { |
| 145 | uint256 maxLeverageRatio; |
| 146 | uint256 minCoverageRatio; |
| 147 | uint256 minLiquidityAmount; |
| 148 | bool allowsDividends; |
| 149 | uint256 reportingFrequencyDays; |
| 150 | } |
| 151 | |
| 152 | mapping(uint256 => MaintenanceCovenants) public covenants; |
| 153 | |
| 154 | /*////////////////////////////////////////////////////////////// |
| 155 | DOCUMENT ANCHORING |
| 156 | //////////////////////////////////////////////////////////////*/ |
| 157 | mapping(uint256 => bytes32) public policyDocumentHash; |
| 158 | mapping(uint256 => string) public policyDocumentURI; |
| 159 | |
| 160 | mapping(uint256 => bool) public eligibilitySet; |
| 161 | mapping(uint256 => bool) public ratiosSet; |
| 162 | mapping(uint256 => bool) public concentrationSet; |
| 163 | mapping(uint256 => bool) public attestationSet; |
| 164 | mapping(uint256 => bool) public covenantsSet; |
| 165 | mapping(uint256 => bool) public hasAtLeastOneTier; |
| 166 | |
| 167 | /*////////////////////////////////////////////////////////////// |
| 168 | EVENTS |
| 169 | //////////////////////////////////////////////////////////////*/ |
| 170 | event PolicyCreated(uint256 version, uint256 timestamp); |
| 171 | event PolicyFrozen(uint256 version, uint256 timestamp); |
| 172 | event PolicyEligibilityUpdated(uint256 version, uint256 timestamp); |
| 173 | event PolicyRatiosUpdated(uint256 version, uint256 timestamp); |
| 174 | event PolicyConcentrationUpdated(uint256 version, uint256 timestamp); |
| 175 | event PolicyAttestationUpdated(uint256 version, uint256 timestamp); |
| 176 | event PolicyCovenantsUpdated(uint256 version, uint256 timestamp); |
| 177 | event LoanTierUpdated(uint256 version, uint8 tierId, uint256 timestamp); |
| 178 | event IndustryExcluded( |
| 179 | uint256 version, |
| 180 | bytes32 industry, |
| 181 | uint256 timestamp |
| 182 | ); |
| 183 | event MaxTiersChanged(uint8 maxTiers); |
| 184 | event IndustryIncluded( |
| 185 | uint256 version, |
| 186 | bytes32 industry, |
| 187 | uint256 timestamp |
| 188 | ); |
| 189 | |
| 190 | event PolicyAdminChanged(address newAdmin); |
| 191 | |
| 192 | event PolicyDocumentSet( |
| 193 | uint256 version, |
| 194 | bytes32 hash, |
| 195 | string uri, |
| 196 | uint256 timestamp |
| 197 | ); |
| 198 | event PolicyDeactivated(uint256 version, uint256 timestamp); |
| 199 | |
| 200 | /*////////////////////////////////////////////////////////////// |
| 201 | CONSTRUCTOR |
| 202 | //////////////////////////////////////////////////////////////*/ |
| 203 | constructor() { |
| 204 | policyAdmin = msg.sender; |
| 205 | } |
| 206 | |
| 207 | /*////////////////////////////////////////////////////////////// |
| 208 | POLICY CREATION |
| 209 | //////////////////////////////////////////////////////////////*/ |
| 210 | |
| 211 | function createPolicy(uint256 version) external onlyAdmin { |
| 212 | if (version == 0) { |
| 213 | revert CreditPolicy__InvalidVersion(); |
| 214 | } |
| 215 | if (policyCreated[version]) { |
| 216 | revert CreditPolicy__PolicyVersionExists(version); |
| 217 | } |
| 218 | |
| 219 | policyCreated[version] = true; |
| 220 | policyActive[version] = true; |
| 221 | lastUpdated[version] = block.timestamp; |
| 222 | emit PolicyCreated(version, block.timestamp); |
| 223 | } |
| 224 | |
| 225 | function freezePolicy( |
| 226 | uint256 version |
| 227 | ) external onlyAdmin policyExists(version) { |
| 228 | if (policyFrozen[version]) { |
| 229 | revert CreditPolicy__PolicyFrozen(version); |
| 230 | } |
| 231 | if (policyActive[version] == false) { |
| 232 | revert CreditPolicy__PolicyNotActive(version); |
| 233 | } |
| 234 | if ( |
| 235 | !eligibilitySet[version] || |
| 236 | !ratiosSet[version] || |
| 237 | !concentrationSet[version] || |
| 238 | !attestationSet[version] || |
| 239 | !covenantsSet[version] || |
| 240 | !hasAtLeastOneTier[version] |
| 241 | ) { |
| 242 | revert CreditPolicy__IncompletePolicy(version); |
| 243 | } |
| 244 | if (policyDocumentHash[version] == bytes32(0)) { |
| 245 | revert CreditPolicy__IncompletePolicy(version); |
| 246 | } |
| 247 | |
| 248 | policyFrozen[version] = true; |
| 249 | lastUpdated[version] = block.timestamp; |
| 250 | emit PolicyFrozen(version, block.timestamp); |
| 251 | } |
| 252 | |
| 253 | function deActivatePolicy( |
| 254 | uint256 version |
| 255 | ) external onlyAdmin policyExists(version) { |
| 256 | policyActive[version] = false; |
| 257 | lastUpdated[version] = block.timestamp; |
| 258 | emit PolicyDeactivated(version, block.timestamp); |
| 259 | } |
| 260 | |
| 261 | /*////////////////////////////////////////////////////////////// |
| 262 | ELIGIBILITY UPDATE |
| 263 | //////////////////////////////////////////////////////////////*/ |
| 264 | function updateEligibility( |
| 265 | uint256 version, |
| 266 | EligibilityCriteria calldata data |
| 267 | ) external onlyAdmin policyExists(version) policyEditable(version) { |
| 268 | eligibility[version] = data; |
| 269 | lastUpdated[version] = block.timestamp; |
| 270 | eligibilitySet[version] = true; |
| 271 | emit PolicyEligibilityUpdated(version, block.timestamp); |
| 272 | } |
| 273 | |
| 274 | /*////////////////////////////////////////////////////////////// |
| 275 | RATIOS UPDATE |
| 276 | //////////////////////////////////////////////////////////////*/ |
| 277 | function updateRatios( |
| 278 | uint256 version, |
| 279 | FinancialRatios calldata data |
| 280 | ) external onlyAdmin policyExists(version) policyEditable(version) { |
| 281 | ratios[version] = data; |
| 282 | lastUpdated[version] = block.timestamp; |
| 283 | ratiosSet[version] = true; |
| 284 | emit PolicyRatiosUpdated(version, block.timestamp); |
| 285 | } |
| 286 | |
| 287 | /*////////////////////////////////////////////////////////////// |
| 288 | CONCENTRATION UPDATE |
| 289 | //////////////////////////////////////////////////////////////*/ |
| 290 | function updateConcentration( |
| 291 | uint256 version, |
| 292 | ConcentrationLimits calldata data |
| 293 | ) external onlyAdmin policyExists(version) policyEditable(version) { |
| 294 | concentration[version] = data; |
| 295 | lastUpdated[version] = block.timestamp; |
| 296 | concentrationSet[version] = true; |
| 297 | emit PolicyConcentrationUpdated(version, block.timestamp); |
| 298 | } |
| 299 | |
| 300 | /*////////////////////////////////////////////////////////////// |
| 301 | ATTESTATION UPDATE |
| 302 | //////////////////////////////////////////////////////////////*/ |
| 303 | function updateAttestation( |
| 304 | uint256 version, |
| 305 | AttestationRequirements calldata data |
| 306 | ) external onlyAdmin policyExists(version) policyEditable(version) { |
| 307 | attestation[version] = data; |
| 308 | lastUpdated[version] = block.timestamp; |
| 309 | attestationSet[version] = true; |
| 310 | emit PolicyAttestationUpdated(version, block.timestamp); |
| 311 | } |
| 312 | |
| 313 | /*////////////////////////////////////////////////////////////// |
| 314 | COVENANT UPDATE |
| 315 | //////////////////////////////////////////////////////////////*/ |
| 316 | function updateCovenants( |
| 317 | uint256 version, |
| 318 | MaintenanceCovenants calldata data |
| 319 | ) external onlyAdmin policyExists(version) policyEditable(version) { |
| 320 | covenants[version] = data; |
| 321 | lastUpdated[version] = block.timestamp; |
| 322 | covenantsSet[version] = true; |
| 323 | emit PolicyCovenantsUpdated(version, block.timestamp); |
| 324 | } |
| 325 | |
| 326 | /*////////////////////////////////////////////////////////////// |
| 327 | LOAN TIERS |
| 328 | //////////////////////////////////////////////////////////////*/ |
| 329 | function setLoanTier( |
| 330 | uint256 version, |
| 331 | uint8 tierId, |
| 332 | LoanTier calldata tier |
| 333 | ) external onlyAdmin policyExists(version) policyEditable(version) { |
| 334 | if (tierId >= maxTiers) { |
| 335 | revert CreditPolicy__InvalidTierCount(tierId); |
| 336 | } |
| 337 | loanTiers[version][tierId] = tier; |
| 338 | tierExists[version][tierId] = true; |
| 339 | if (tierId >= totalTiers[version]) { |
| 340 | totalTiers[version] = tierId + 1; |
| 341 | } |
| 342 | hasAtLeastOneTier[version] = true; |
| 343 | lastUpdated[version] = block.timestamp; |
| 344 | emit LoanTierUpdated(version, tierId, block.timestamp); |
| 345 | } |
| 346 | |
| 347 | /*////////////////////////////////////////////////////////////// |
| 348 | INDUSTRY CONTROLS |
| 349 | //////////////////////////////////////////////////////////////*/ |
| 350 | function excludeIndustry( |
| 351 | uint256 version, |
| 352 | bytes32 industry |
| 353 | ) external onlyAdmin policyExists(version) policyEditable(version) { |
| 354 | if (industry == bytes32(0)) { |
| 355 | revert CreditPolicy__InvalidIndustryHash(); |
| 356 | } |
| 357 | excludedIndustries[version][industry] = true; |
| 358 | lastUpdated[version] = block.timestamp; |
| 359 | emit IndustryExcluded(version, industry, block.timestamp); |
| 360 | } |
| 361 | |
| 362 | function includeIndustry( |
| 363 | uint256 version, |
| 364 | bytes32 industry |
| 365 | ) external onlyAdmin policyExists(version) policyEditable(version) { |
| 366 | if (industry == bytes32(0)) { |
| 367 | revert CreditPolicy__InvalidIndustryHash(); |
| 368 | } |
| 369 | excludedIndustries[version][industry] = false; |
| 370 | lastUpdated[version] = block.timestamp; |
| 371 | emit IndustryIncluded(version, industry, block.timestamp); |
| 372 | } |
| 373 | |
| 374 | /*////////////////////////////////////////////////////////////// |
| 375 | DOCUMENT UPDATE |
| 376 | //////////////////////////////////////////////////////////////*/ |
| 377 | function setPolicyDocument( |
| 378 | uint256 version, |
| 379 | bytes32 hash, |
| 380 | string calldata uri |
| 381 | ) external onlyAdmin policyExists(version) policyEditable(version) { |
| 382 | policyDocumentHash[version] = hash; |
| 383 | policyDocumentURI[version] = uri; |
| 384 | lastUpdated[version] = block.timestamp; |
| 385 | |
| 386 | emit PolicyDocumentSet(version, hash, uri, block.timestamp); |
| 387 | } |
| 388 | |
| 389 | function changePolicyAdmin(address newAdmin) external onlyAdmin { |
| 390 | if (newAdmin == address(0)) { |
| 391 | revert CreditPolicy__InvalidAdmin(); |
| 392 | } |
| 393 | policyAdmin = newAdmin; |
| 394 | |
| 395 | emit PolicyAdminChanged(newAdmin); |
| 396 | } |
| 397 | |
| 398 | // getters for interface compliance |
| 399 | |
| 400 | function isPolicyActive(uint256 version) external view returns (bool) { |
| 401 | return policyActive[version]; |
| 402 | } |
| 403 | |
| 404 | function isPolicyFrozen(uint256 version) external view returns (bool) { |
| 405 | return policyFrozen[version]; |
| 406 | } |
| 407 | |
| 408 | function tierExistsInPolicy( |
| 409 | uint256 version, |
| 410 | uint8 tierId |
| 411 | ) external view returns (bool) { |
| 412 | return tierExists[version][tierId]; |
| 413 | } |
| 414 | |
| 415 | function setMaxTiers(uint8 _maxTiers) external onlyAdmin { |
| 416 | if (_maxTiers == 255) { |
| 417 | revert CreditPolicy__InvalidTierCount(_maxTiers); |
| 418 | } |
| 419 | maxTiers = _maxTiers; |
| 420 | emit MaxTiersChanged(_maxTiers); |
| 421 | } |
| 422 | |
| 423 | function getMaxTiers() external view returns (uint8) { |
| 424 | return maxTiers; |
| 425 | } |
| 426 | |
| 427 | function isIndustryExcluded( |
| 428 | uint256 version, |
| 429 | bytes32 industry |
| 430 | ) external view returns (bool) { |
| 431 | return excludedIndustries[version][industry]; |
| 432 | } |
| 433 | } |
| 434 |
8.0%
src/LoanEngine.sol
Lines covered: 12 / 137 (8.0%)
| 1 | // SPDX-License-Identifier: MIT |
| 2 | pragma solidity ^0.8.24; |
| 3 | |
| 4 | import {Ownable} from "@openzeppelin/contracts/access/Ownable.sol"; |
| 5 | import {ICreditPolicy} from "./interfaces/ICreditPolicy.sol"; |
| 6 | import {IVerifier} from "./interfaces/IVerifier.sol"; |
| 7 | import {ITranchePool} from "./interfaces/ITranchePool.sol"; |
| 8 | import {ReentrancyGuard} from "@openzeppelin/contracts/utils/ReentrancyGuard.sol"; |
| 9 | import {SafeERC20, IERC20} from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol"; |
| 10 | import {TranchePool} from "./TranchePool.sol"; |
| 11 | |
| 12 | contract LoanEngine is Ownable, ReentrancyGuard { |
| 13 | using SafeERC20 for IERC20; |
| 14 | /*////////////////////////////////////////////////////////////// |
| 15 | ERRORS |
| 16 | //////////////////////////////////////////////////////////////*/ |
| 17 | |
| 18 | error LoanEngine__PolicyNotFrozen(uint256 policyVersion); |
| 19 | error LoanEngine__InvalidProof(); |
| 20 | error LoanEngine__LoanTierIsNotInPolicy( |
| 21 | uint256 policyVersion, |
| 22 | uint8 tierId |
| 23 | ); |
| 24 | error LoanEngine__InvalidLoanParameters( |
| 25 | uint256 loanId, |
| 26 | uint256 principalIssued, |
| 27 | uint256 aprBps, |
| 28 | uint256 termDays |
| 29 | ); |
| 30 | error LoanEngine__MaxOriginationFeeExceeded( |
| 31 | uint256 loanId, |
| 32 | uint256 originationFeeBps, |
| 33 | uint256 maxOriginationFeeBps |
| 34 | ); |
| 35 | error LoanEngine__PoolNotDeployed(); |
| 36 | error LoanEngine__InvalidOffRampingEntity(address entity); |
| 37 | error LoanEngine__LoanExists(uint256 loanId); |
| 38 | error LoanEngine__LoanIsNotInCreatedState(uint256 loanId); |
| 39 | error LoanEngine__LoanIsNotActive(uint256 loanId); |
| 40 | error LoanEngine__LoanIsNotDefaulted(uint256 loanId); |
| 41 | error LoanEngine__InvalidRepayment(); |
| 42 | error LoanEngine__ZeroRecovery(); |
| 43 | error LoanEngine__LoanNotRecoverable(uint256 loanId); |
| 44 | error LoanEngine__ZeroLossOnWriteOff(uint256 loanId); |
| 45 | error LoanEngine__InvalidFeeManagerEntity(address manager); |
| 46 | error LoanEngine__InvalidRecoveryAgent(address agent); |
| 47 | error LoanEngine__InvalidRepaymentAgent(address agent); |
| 48 | error LoanEngine__InsufficientPoolLiquidity(); |
| 49 | error LoanEngine__ProofAlreadyUsed(); |
| 50 | modifier isWhiteListedOffRampingEntity(address entity) { |
| 51 | _isWhiteListedOffRampingEntity(entity); |
| 52 | _; |
| 53 | } |
| 54 | |
| 55 | function _isWhiteListedOffRampingEntity(address entity) internal view { |
| 56 | if (!whitelistedOffRampingEntities[entity]) { |
| 57 | revert LoanEngine__InvalidOffRampingEntity(entity); |
| 58 | } |
| 59 | } |
| 60 | |
| 61 | modifier isWhiteListedRecoveryAgent(address agent) { |
| 62 | _isWhiteListedRecoveryAgent(agent); |
| 63 | _; |
| 64 | } |
| 65 | |
| 66 | function _isWhiteListedRecoveryAgent(address agent) internal view { |
| 67 | if (!whitelistedRecoveryAgents[agent]) { |
| 68 | revert LoanEngine__InvalidRecoveryAgent(agent); |
| 69 | } |
| 70 | } |
| 71 | |
| 72 | modifier isWhiteListedRepaymentAgent(address agent) { |
| 73 | _isWhiteListedRepaymentAgent(agent); |
| 74 | _; |
| 75 | } |
| 76 | |
| 77 | function _isWhiteListedRepaymentAgent(address agent) internal view { |
| 78 | if (!whitelistedRepaymentAgents[agent]) { |
| 79 | revert LoanEngine__InvalidRepaymentAgent(agent); |
| 80 | } |
| 81 | } |
| 82 | |
| 83 | modifier isWhiteListedFeeManager(address manager) { |
| 84 | _isWhiteListedFeeManager(manager); |
| 85 | _; |
| 86 | } |
| 87 | |
| 88 | function _isWhiteListedFeeManager(address manager) internal view { |
| 89 | if (!whitelistedFeeManagers[manager]) { |
| 90 | revert LoanEngine__InvalidFeeManagerEntity(manager); |
| 91 | } |
| 92 | } |
| 93 | |
| 94 | ICreditPolicy public creditPolicyContract; |
| 95 | IVerifier loanProofVerifier; |
| 96 | ITranchePool tranchePool; |
| 97 | |
| 98 | mapping(uint256 loanId => Loan) public s_loans; |
| 99 | mapping(uint256 loanId => uint256) public s_originationFees; |
| 100 | mapping(address whitelistedOffRampingEntity => bool) |
| 101 | public whitelistedOffRampingEntities; |
| 102 | mapping(address whiteListedRecoveryAgent => bool) |
| 103 | public whitelistedRecoveryAgents; |
| 104 | |
| 105 | mapping(address whiteListedRepaymentAgent => bool) |
| 106 | public whitelistedRepaymentAgents; |
| 107 | |
| 108 | mapping(address whiteListedFeeManager => bool) |
| 109 | public whitelistedFeeManagers; |
| 110 | mapping(bytes32 nullifierHash => bool) public s_nullifierHashes; |
| 111 | uint256 public s_nextLoanId = 1; |
| 112 | uint256 public s_maxOriginationFeeBps; |
| 113 | address public s_stableCoinAddress; |
| 114 | uint256 public constant STANDARD_BPS = 100; |
| 115 | enum LoanState { |
| 116 | NONE, |
| 117 | CREATED, |
| 118 | ACTIVE, |
| 119 | REPAID, |
| 120 | DEFAULTED, |
| 121 | WRITTEN_OFF |
| 122 | } |
| 123 | |
| 124 | struct Loan { |
| 125 | // Identity |
| 126 | uint256 loanId; |
| 127 | bytes32 borrowerCommitment; |
| 128 | uint256 policyVersion; |
| 129 | uint8 tierId; |
| 130 | // Economics |
| 131 | uint256 principalIssued; |
| 132 | uint256 principalOutstanding; |
| 133 | uint256 aprBps; |
| 134 | uint256 originationFeeBps; |
| 135 | // Interest accounting |
| 136 | uint256 interestAccrued; |
| 137 | uint256 interestPaid; |
| 138 | uint256 lastAccrualTimestamp; |
| 139 | // Timing |
| 140 | uint256 startTimestamp; |
| 141 | uint256 maturityTimestamp; |
| 142 | uint256 termDays; |
| 143 | // State |
| 144 | LoanState state; |
| 145 | uint256 totalRecovered; |
| 146 | // allocation_ratio |
| 147 | uint256 seniorPrincipalAllocated; |
| 148 | uint256 juniorPrincipalAllocated; |
| 149 | } |
| 150 | |
| 151 | /*////////////////////////////////////////////////////////////// |
| 152 | EVENTS |
| 153 | //////////////////////////////////////////////////////////////*/ |
| 154 | |
| 155 | event LoanCreated( |
| 156 | uint256 indexed loanId, |
| 157 | bytes32 borrowerCommitment, |
| 158 | uint256 principalIssued, |
| 159 | uint8 tierId, |
| 160 | uint256 timestamp |
| 161 | ); |
| 162 | |
| 163 | event LoanActivated( |
| 164 | uint256 indexed loanId, |
| 165 | uint256 principalIssued, |
| 166 | uint256 timestamp, |
| 167 | uint256 startTimestamp, |
| 168 | uint256 maturityTimestamp |
| 169 | ); |
| 170 | |
| 171 | event LoanRepaid( |
| 172 | uint256 indexed loanId, |
| 173 | uint256 principalRepaid, |
| 174 | uint256 interestRepaid, |
| 175 | uint256 timestamp |
| 176 | ); |
| 177 | |
| 178 | event LoanClosed(uint256 indexed loanId, uint256 timestamp); |
| 179 | |
| 180 | event LoanDefaulted( |
| 181 | uint256 indexed loanId, |
| 182 | bytes32 reasonHash, |
| 183 | uint256 timestamp |
| 184 | ); |
| 185 | |
| 186 | event LoanWrittenOff(uint256 indexed loanId, uint256 timestamp); |
| 187 | |
| 188 | event LoanRecovered( |
| 189 | uint256 indexed loanId, |
| 190 | uint256 amount, |
| 191 | uint256 timestamp |
| 192 | ); |
| 193 | |
| 194 | constructor( |
| 195 | address _creditPolicyContract, |
| 196 | address _loanProofVerifier, |
| 197 | uint256 _maxOriginationFeeBps, |
| 198 | address _tranchePool, |
| 199 | address _stableCoinAddress |
| 200 | ) Ownable(msg.sender) { |
| 201 | creditPolicyContract = ICreditPolicy(_creditPolicyContract); |
| 202 | loanProofVerifier = IVerifier(_loanProofVerifier); |
| 203 | s_maxOriginationFeeBps = _maxOriginationFeeBps; |
| 204 | tranchePool = ITranchePool(_tranchePool); |
| 205 | s_stableCoinAddress = _stableCoinAddress; |
| 206 | } |
| 207 | |
| 208 | // A notarization step that records a policy-compliant loan intent on-chain |
| 209 | // TODO: public inputs needed to be verified against the contract state |
| 210 | // will be implemented after the public inputs structure is finalized |
| 211 | // preconditions |
| 212 | // borrowerCommitment should match the publicinput commitment |
| 213 | // all the parameteres should match the public inputs |
| 214 | function createLoan( |
| 215 | bytes32 borrowerCommitment, |
| 216 | bytes32 nullifierHash, |
| 217 | uint256 policyVersion, |
| 218 | uint8 tierId, |
| 219 | uint256 principalIssued, |
| 220 | uint256 aprBps, |
| 221 | uint256 originationFeeBps, |
| 222 | uint256 termDays, |
| 223 | bytes32 industry, |
| 224 | bytes calldata proofData, |
| 225 | bytes32[] calldata publicInputs |
| 226 | ) external onlyOwner { |
| 227 | if (s_loans[s_nextLoanId].state != LoanState.NONE) { |
| 228 | revert LoanEngine__LoanExists(s_nextLoanId); |
| 229 | } |
| 230 | // Implementation goes here |
| 231 | if (!creditPolicyContract.isPolicyFrozen(policyVersion)) { |
| 232 | revert LoanEngine__PolicyNotFrozen(policyVersion); |
| 233 | } |
| 234 | |
| 235 | if (creditPolicyContract.isIndustryExcluded(policyVersion, industry)) { |
| 236 | revert LoanEngine__PolicyNotFrozen(policyVersion); |
| 237 | } |
| 238 | |
| 239 | if (!creditPolicyContract.tierExistsInPolicy(policyVersion, tierId)) { |
| 240 | revert LoanEngine__LoanTierIsNotInPolicy(policyVersion, tierId); |
| 241 | } |
| 242 | |
| 243 | if (s_nullifierHashes[nullifierHash]) { |
| 244 | revert LoanEngine__ProofAlreadyUsed(); |
| 245 | } |
| 246 | |
| 247 | if (loanProofVerifier.verify(proofData, publicInputs) == false) { |
| 248 | revert LoanEngine__InvalidProof(); |
| 249 | } |
| 250 | |
| 251 | if ( |
| 252 | tranchePool.getPoolState() != TranchePool.PoolState.DEPLOYED && |
| 253 | tranchePool.getPoolState() != TranchePool.PoolState.COMMITED |
| 254 | ) { |
| 255 | revert LoanEngine__PoolNotDeployed(); |
| 256 | } |
| 257 | |
| 258 | if (principalIssued == 0 || aprBps == 0 || termDays == 0) { |
| 259 | revert LoanEngine__InvalidLoanParameters( |
| 260 | s_nextLoanId, |
| 261 | principalIssued, |
| 262 | aprBps, |
| 263 | termDays |
| 264 | ); |
| 265 | } |
| 266 | |
| 267 | if (originationFeeBps > s_maxOriginationFeeBps) { |
| 268 | revert LoanEngine__MaxOriginationFeeExceeded( |
| 269 | s_nextLoanId, |
| 270 | originationFeeBps, |
| 271 | s_maxOriginationFeeBps |
| 272 | ); |
| 273 | } |
| 274 | |
| 275 | if (principalIssued > tranchePool.getTotalIdleValue()) { |
| 276 | revert LoanEngine__InsufficientPoolLiquidity(); |
| 277 | } |
| 278 | |
| 279 | Loan memory newLoan = Loan({ |
| 280 | loanId: s_nextLoanId, |
| 281 | borrowerCommitment: borrowerCommitment, |
| 282 | policyVersion: policyVersion, |
| 283 | tierId: tierId, |
| 284 | principalIssued: principalIssued, |
| 285 | principalOutstanding: 0, |
| 286 | aprBps: aprBps, |
| 287 | originationFeeBps: originationFeeBps, |
| 288 | interestAccrued: 0, |
| 289 | interestPaid: 0, |
| 290 | lastAccrualTimestamp: 0, |
| 291 | startTimestamp: 0, |
| 292 | maturityTimestamp: 0, |
| 293 | termDays: termDays, |
| 294 | state: LoanState.CREATED, |
| 295 | totalRecovered: 0, |
| 296 | seniorPrincipalAllocated: 0, |
| 297 | juniorPrincipalAllocated: 0 |
| 298 | }); |
| 299 | |
| 300 | s_loans[s_nextLoanId++] = newLoan; |
| 301 | s_nullifierHashes[nullifierHash] = true; |
| 302 | |
| 303 | emit LoanCreated( |
| 304 | newLoan.loanId, |
| 305 | borrowerCommitment, |
| 306 | principalIssued, |
| 307 | tierId, |
| 308 | block.timestamp |
| 309 | ); |
| 310 | } |
| 311 | |
| 312 | /* |
| 313 | preconditions |
| 314 | - onlyOwner |
| 315 | - loan must already exist |
| 316 | - loan.state == CREATED |
| 317 | */ |
| 318 | function activateLoan( |
| 319 | uint256 loanId, |
| 320 | address receivingEntity, |
| 321 | address feeManager |
| 322 | ) |
| 323 | external |
| 324 | onlyOwner |
| 325 | isWhiteListedOffRampingEntity(receivingEntity) |
| 326 | isWhiteListedFeeManager(feeManager) |
| 327 | nonReentrant |
| 328 | { |
| 329 | // Implementation goes here |
| 330 | Loan storage loan = s_loans[loanId]; |
| 331 | |
| 332 | if (loan.state != LoanState.CREATED) { |
| 333 | revert LoanEngine__LoanIsNotInCreatedState(loanId); |
| 334 | } |
| 335 | loan.principalOutstanding = loan.principalIssued; |
| 336 | loan.lastAccrualTimestamp = block.timestamp; |
| 337 | loan.startTimestamp = block.timestamp; |
| 338 | loan.maturityTimestamp = block.timestamp + (loan.termDays * 1 days); |
| 339 | loan.state = LoanState.ACTIVE; |
| 340 | |
| 341 | uint256 originationFee = (loan.principalIssued * |
| 342 | loan.originationFeeBps) / 10000; |
| 343 | |
| 344 | s_originationFees[loanId] = originationFee; |
| 345 | |
| 346 | if (loan.principalIssued > tranchePool.getTotalIdleValue()) { |
| 347 | revert LoanEngine__InsufficientPoolLiquidity(); |
| 348 | } |
| 349 | |
| 350 | uint256 totalDisbursement = loan.principalIssued - originationFee; |
| 351 | (uint256 seniorAmount, uint256 juniorAmount, ) = tranchePool |
| 352 | .allocateCapital( |
| 353 | totalDisbursement, |
| 354 | originationFee, |
| 355 | receivingEntity, |
| 356 | feeManager |
| 357 | ); |
| 358 | loan.seniorPrincipalAllocated = seniorAmount; |
| 359 | |
| 360 | loan.juniorPrincipalAllocated = juniorAmount; |
| 361 | |
| 362 | emit LoanActivated( |
| 363 | loan.loanId, |
| 364 | loan.principalIssued, |
| 365 | block.timestamp, |
| 366 | loan.startTimestamp, |
| 367 | loan.maturityTimestamp |
| 368 | ); |
| 369 | } |
| 370 | |
| 371 | function repayLoan( |
| 372 | uint256 loanId, |
| 373 | uint256 principalAmount, |
| 374 | uint256 interestAmount, |
| 375 | address repaymentAgent |
| 376 | ) |
| 377 | external |
| 378 | onlyOwner |
| 379 | isWhiteListedRepaymentAgent(repaymentAgent) |
| 380 | nonReentrant |
| 381 | { |
| 382 | Loan storage loan = s_loans[loanId]; |
| 383 | if (loan.state != LoanState.ACTIVE) { |
| 384 | revert LoanEngine__LoanIsNotActive(loanId); |
| 385 | } |
| 386 | |
| 387 | uint256 totalPayment = principalAmount + interestAmount; |
| 388 | if (totalPayment == 0) { |
| 389 | revert LoanEngine__InvalidRepayment(); |
| 390 | } |
| 391 | |
| 392 | _accrueInterest(loanId); |
| 393 | |
| 394 | // 1️⃣ Transfer funds to pool (settlement layer) |
| 395 | IERC20(s_stableCoinAddress).safeTransferFrom( |
| 396 | repaymentAgent, |
| 397 | address(tranchePool), |
| 398 | totalPayment |
| 399 | ); |
| 400 | |
| 401 | // 2️⃣ Interest first |
| 402 | uint256 interestDue = loan.interestAccrued; |
| 403 | uint256 interestPaid = totalPayment > interestDue |
| 404 | ? interestDue |
| 405 | : totalPayment; |
| 406 | |
| 407 | // 3️⃣ Principal second |
| 408 | uint256 remainingForPrincipal = totalPayment - interestPaid; |
| 409 | uint256 principalDue = loan.principalOutstanding; |
| 410 | |
| 411 | uint256 principalPaid = remainingForPrincipal > principalDue |
| 412 | ? principalDue |
| 413 | : remainingForPrincipal; |
| 414 | |
| 415 | // 4️⃣ Update loan accounting |
| 416 | loan.interestAccrued -= interestPaid; |
| 417 | loan.interestPaid += interestPaid; |
| 418 | loan.principalOutstanding -= principalPaid; |
| 419 | |
| 420 | bool fullyRepaid = loan.principalOutstanding == 0 && |
| 421 | loan.interestAccrued == 0; |
| 422 | |
| 423 | if (fullyRepaid) { |
| 424 | loan.state = LoanState.REPAID; |
| 425 | } |
| 426 | |
| 427 | tranchePool.onRepayment(principalPaid, interestPaid); |
| 428 | |
| 429 | emit LoanRepaid( |
| 430 | loan.loanId, |
| 431 | principalPaid, |
| 432 | interestPaid, |
| 433 | block.timestamp |
| 434 | ); |
| 435 | |
| 436 | if (fullyRepaid) { |
| 437 | emit LoanClosed(loanId, block.timestamp); |
| 438 | } |
| 439 | } |
| 440 | |
| 441 | function declareDefault( |
| 442 | uint256 loanId, |
| 443 | bytes32 reasonHash |
| 444 | ) external onlyOwner { |
| 445 | // Implementation goes here |
| 446 | Loan storage loan = s_loans[loanId]; |
| 447 | if (loan.state != LoanState.ACTIVE) { |
| 448 | revert LoanEngine__LoanIsNotActive(loanId); |
| 449 | } |
| 450 | _accrueInterest(loanId); |
| 451 | loan.state = LoanState.DEFAULTED; |
| 452 | emit LoanDefaulted(loanId, reasonHash, block.timestamp); |
| 453 | } |
| 454 | |
| 455 | function writeOffLoan(uint256 loanId) external onlyOwner { |
| 456 | // Implementation goes here |
| 457 | Loan storage loan = s_loans[loanId]; |
| 458 | if (loan.state != LoanState.DEFAULTED) { |
| 459 | revert LoanEngine__LoanIsNotDefaulted(loanId); |
| 460 | } |
| 461 | uint256 loss = loan.principalOutstanding; |
| 462 | uint256 interestAccrued = loan.interestAccrued; |
| 463 | if (loss == 0) { |
| 464 | revert LoanEngine__ZeroLossOnWriteOff(loanId); |
| 465 | } |
| 466 | |
| 467 | loan.principalOutstanding = 0; |
| 468 | loan.interestAccrued = 0; |
| 469 | loan.state = LoanState.WRITTEN_OFF; |
| 470 | tranchePool.onLoss(loss, interestAccrued); |
| 471 | emit LoanWrittenOff(loanId, block.timestamp); |
| 472 | } |
| 473 | |
| 474 | function recoverLoan( |
| 475 | uint256 loanId, |
| 476 | uint256 amount, |
| 477 | address recoveryAgent |
| 478 | ) external onlyOwner isWhiteListedRecoveryAgent(recoveryAgent) { |
| 479 | Loan storage loan = s_loans[loanId]; |
| 480 | if (loan.state != LoanState.WRITTEN_OFF) { |
| 481 | revert LoanEngine__LoanNotRecoverable(loanId); |
| 482 | } |
| 483 | if (amount == 0) { |
| 484 | revert LoanEngine__ZeroRecovery(); |
| 485 | } |
| 486 | loan.totalRecovered += amount; |
| 487 | IERC20(s_stableCoinAddress).safeTransferFrom( |
| 488 | recoveryAgent, |
| 489 | address(tranchePool), |
| 490 | amount |
| 491 | ); |
| 492 | tranchePool.onRecovery(amount); |
| 493 | emit LoanRecovered(loanId, amount, block.timestamp); |
| 494 | } |
| 495 | |
| 496 | function _accrueInterest(uint256 loanId) internal { |
| 497 | // Implementation goes here |
| 498 | Loan storage loan = s_loans[loanId]; |
| 499 | if (loan.state != LoanState.ACTIVE) { |
| 500 | revert LoanEngine__LoanIsNotActive(loanId); |
| 501 | } |
| 502 | uint256 timeElapsed = block.timestamp - loan.lastAccrualTimestamp; |
| 503 | if (loan.principalOutstanding == 0) { |
| 504 | loan.lastAccrualTimestamp = block.timestamp; |
| 505 | return; |
| 506 | } |
| 507 | |
| 508 | uint256 interest = (loan.principalOutstanding * |
| 509 | loan.aprBps * |
| 510 | timeElapsed) / (365 days * 10_000); |
| 511 | |
| 512 | if (interest > 0) { |
| 513 | loan.interestAccrued += interest; |
| 514 | uint256 totalAllocated = loan.principalIssued; |
| 515 | uint256 seniorInterest = (interest * |
| 516 | loan.seniorPrincipalAllocated) / totalAllocated; |
| 517 | |
| 518 | uint256 juniorInterest = (interest * |
| 519 | loan.juniorPrincipalAllocated) / totalAllocated; |
| 520 | tranchePool.onInterestAccrued( |
| 521 | interest, |
| 522 | seniorInterest, |
| 523 | juniorInterest |
| 524 | ); |
| 525 | } |
| 526 | loan.lastAccrualTimestamp = block.timestamp; |
| 527 | } |
| 528 | |
| 529 | // setters for contract management |
| 530 | |
| 531 | function setMaxOriginationFeeBps( |
| 532 | uint256 _maxOriginationFeeBps |
| 533 | ) external onlyOwner { |
| 534 | s_maxOriginationFeeBps = _maxOriginationFeeBps; |
| 535 | } |
| 536 | |
| 537 | function setWhitelistedOffRampingEntity( |
| 538 | address entity, |
| 539 | bool isWhitelisted |
| 540 | ) external onlyOwner { |
| 541 | whitelistedOffRampingEntities[entity] = isWhitelisted; |
| 542 | } |
| 543 | |
| 544 | function setWhitelistedRecoveryAgent( |
| 545 | address agent, |
| 546 | bool isWhitelisted |
| 547 | ) external onlyOwner { |
| 548 | whitelistedRecoveryAgents[agent] = isWhitelisted; |
| 549 | } |
| 550 | |
| 551 | function setWhitelistedRepaymentAgent( |
| 552 | address agent, |
| 553 | bool isWhitelisted |
| 554 | ) external onlyOwner { |
| 555 | whitelistedRepaymentAgents[agent] = isWhitelisted; |
| 556 | } |
| 557 | |
| 558 | function setWhitelistedFeeManager( |
| 559 | address manager, |
| 560 | bool isWhitelisted |
| 561 | ) external onlyOwner { |
| 562 | whitelistedFeeManagers[manager] = isWhitelisted; |
| 563 | } |
| 564 | |
| 565 | function getMaxOriginationFeeBps() external view returns (uint256) { |
| 566 | return s_maxOriginationFeeBps; |
| 567 | } |
| 568 | |
| 569 | function getNextLoanId() external view returns (uint256) { |
| 570 | return s_nextLoanId; |
| 571 | } |
| 572 | |
| 573 | function getLoanDetails( |
| 574 | uint256 loanId |
| 575 | ) external view returns (Loan memory) { |
| 576 | return s_loans[loanId]; |
| 577 | } |
| 578 | } |
| 579 |
11.0%
src/TranchePool.sol
Lines covered: 50 / 452 (11.0%)
| 1 | // SPDX-License-Identifier: MIT |
| 2 | pragma solidity ^0.8.24; |
| 3 | |
| 4 | import {Ownable} from "@openzeppelin/contracts/access/Ownable.sol"; |
| 5 | import {SafeERC20, IERC20} from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol"; |
| 6 | |
| 7 | contract TranchePool is Ownable { |
| 8 | using SafeERC20 for IERC20; |
| 9 | |
| 10 | // Errors |
| 11 | error TranchePool__NotWhiteListed(address user); |
| 12 | error TranchePool__LessThanDepositThreshold(uint256 amount); |
| 13 | error TranchePool__InvalidAllocationRatio(); |
| 14 | error TranchePool__InsufficientLiquidity(); |
| 15 | error TranchePool__InsufficientShares(); |
| 16 | error TranchePool__ZeroWithdrawal(); |
| 17 | error TranchePool__NotWhiteListedForEquityTranche(address user); |
| 18 | error TranchePool__InvalidTransferAmount(uint256 amount); |
| 19 | error TranchePool__InvalidCaller(address user); |
| 20 | error TranchePool__ZeroAPRError(); |
| 21 | error TranchePool__LossExceededCapital(uint256 remaining); |
| 22 | error TranchePool__ZeroSharesMinted(); |
| 23 | error TranchePool__PoolIsNotOpen(); |
| 24 | error TranchePool__InvalidStateTransition(PoolState state); |
| 25 | error TranchePool__WithdrawNotAllowed(PoolState state); |
| 26 | error TranchePool__ZeroValueError(); |
| 27 | error TranchePool__MaxDepositCapExceeded(uint256 maxCap, uint256 amount); |
| 28 | error TranchePool__PoolIsNotCommited(); |
| 29 | error TranchePool__PrincipalRepaymentExceeded(); |
| 30 | error TranchePool__ZeroAddressError(); |
| 31 | error TranchePool__DeployedCapitalExists(); |
| 32 | error TranchePool__InvalidMaxCapAmount(); |
| 33 | error TranchePool__InvalidMinDepositAmount(); |
| 34 | error TranchePool__InterestNotClaimed(); |
| 35 | // Events |
| 36 | |
| 37 | event PoolStateUpdated(PoolState newState); |
| 38 | |
| 39 | event LossAllocated( |
| 40 | uint256 seniorLoss, |
| 41 | uint256 juniorLoss, |
| 42 | uint256 equityLoss |
| 43 | ); |
| 44 | event WithdrawnFromSeniorTranche( |
| 45 | address indexed user, |
| 46 | uint256 amount, |
| 47 | uint256 sharesBurned, |
| 48 | uint256 time |
| 49 | ); |
| 50 | event WithdrawnFromJuniorTranche( |
| 51 | address indexed user, |
| 52 | uint256 amount, |
| 53 | uint256 sharesBurned, |
| 54 | uint256 time |
| 55 | ); |
| 56 | event WithdrawnFromEquityTranche( |
| 57 | address indexed user, |
| 58 | uint256 amount, |
| 59 | uint256 sharesBurned, |
| 60 | uint256 time |
| 61 | ); |
| 62 | |
| 63 | event FundsDepositedToSeniorTranche( |
| 64 | address indexed user, |
| 65 | uint256 amount, |
| 66 | uint256 shares, |
| 67 | uint256 time |
| 68 | ); |
| 69 | event FundsDepositedToJuniorTranche( |
| 70 | address indexed user, |
| 71 | uint256 amount, |
| 72 | uint256 shares, |
| 73 | uint256 time |
| 74 | ); |
| 75 | event FundsDepositedToEquityTranche( |
| 76 | address indexed user, |
| 77 | uint256 amount, |
| 78 | uint256 shares, |
| 79 | uint256 time |
| 80 | ); |
| 81 | event CapitalAllocated( |
| 82 | uint256 seniorAmount, |
| 83 | uint256 juniorAmount, |
| 84 | uint256 equityAmount, |
| 85 | uint256 time |
| 86 | ); |
| 87 | event RecoverAmountTransferredToTranchePool( |
| 88 | uint256 amount, |
| 89 | uint256 timeStamp |
| 90 | ); |
| 91 | event ProfitTransferredToTranchePool(uint256 amount, uint256 timeStamp); |
| 92 | event CapitalAllocationFactorUpdatedSenior(uint256 newFactor); |
| 93 | event CapitalAllocationFactorUpdatedJunior(uint256 newFactor); |
| 94 | |
| 95 | enum PoolState { |
| 96 | OPEN, // deposits allowed |
| 97 | COMMITED, |
| 98 | DEPLOYED, // capital deployed, deposits paused |
| 99 | CLOSED // withdrawals only |
| 100 | } |
| 101 | |
| 102 | // Whitelist |
| 103 | mapping(address => bool) public whiteListedLps; |
| 104 | mapping(address => bool) public whiteListedForEquityTranche; |
| 105 | |
| 106 | // Shares tracking (instead of amounts) |
| 107 | mapping(address => uint256) public s_seniorTrancheShares; |
| 108 | mapping(address => uint256) public s_juniorTrancheShares; |
| 109 | mapping(address => uint256) public s_equityTrancheShares; |
| 110 | |
| 111 | uint256 public s_totalSeniorShares; |
| 112 | uint256 public s_totalJuniorShares; |
| 113 | uint256 public s_totalEquityShares; |
| 114 | |
| 115 | // Total value in each tranche (this decreases when capital is allocated) |
| 116 | // why some part of the capital should stay idle. |
| 117 | // 1. Liquidity and operational buffer. |
| 118 | // |
| 119 | uint256 public s_seniorTrancheIdleValue; |
| 120 | uint256 public s_juniorTrancheIdleValue; |
| 121 | uint256 public s_equityTrancheIdleValue; |
| 122 | |
| 123 | uint256 public s_seniorTrancheDeployedValue; |
| 124 | uint256 public s_juniorTrancheDeployedValue; |
| 125 | uint256 public s_equityTrancheDeployedValue; |
| 126 | |
| 127 | // Minimum deposits |
| 128 | uint256 public s_minimumDepositAmountSeniorTranche; |
| 129 | uint256 public s_minimumDepositAmountJuniorTranche; |
| 130 | uint256 public s_minimumDepositAmountEquityTranche; |
| 131 | |
| 132 | // CHANGED: global interest index (scaled) |
| 133 | uint256 public seniorInterestIndex; // 1e18 precision |
| 134 | uint256 public juniorInterestIndex; // 1e18 precision |
| 135 | uint256 public equityInterestIndex; // 1e18 precision |
| 136 | |
| 137 | // CHANGED: per-user last claimed index |
| 138 | mapping(address => uint256) public seniorUserIndex; |
| 139 | mapping(address => uint256) public juniorUserIndex; |
| 140 | mapping(address => uint256) public equityUserIndex; |
| 141 | |
| 142 | // Stable coin |
| 143 | address public s_stableCoin; |
| 144 | address public loanEngine; |
| 145 | |
| 146 | // Capital allocation factor (e.g., 80 for 80% senior, 15% junior, 5% equity) |
| 147 | uint256 public s_capital_allocation_factor_senior; |
| 148 | uint256 public s_capital_allocation_factor_junior; |
| 149 | |
| 150 | uint256 public s_senior_apr; |
| 151 | uint256 public s_target_junior_apr; |
| 152 | |
| 153 | uint256 public seniorAccruedInterest; |
| 154 | uint256 public juniorAccruedInterest; |
| 155 | uint256 public equityAccruedInterest; |
| 156 | |
| 157 | uint256 public s_seniorTrancheMaxCap; |
| 158 | uint256 public s_juniorTrancheMaxCap; |
| 159 | uint256 public s_equityTrancheMaxCap; |
| 160 | |
| 161 | uint256 public s_protocolRevenue; |
| 162 | uint256 public s_totalDeposited; |
| 163 | uint256 public s_totalLoss; |
| 164 | uint256 public s_totalRecovered; |
| 165 | |
| 166 | PoolState public poolState = PoolState.OPEN; |
| 167 | |
| 168 | uint256 public seniorPrincipalShortfall; |
| 169 | uint256 public juniorPrincipalShortfall; |
| 170 | uint256 public equityPrincipalShortfall; |
| 171 | |
| 172 | modifier isWhiteListed(address user) { |
| 173 | _isWhiteListed(user); |
| 174 | _; |
| 175 | } |
| 176 | |
| 177 | function _isWhiteListed(address user) internal view { |
| 178 | if (!whiteListedLps[user]) { |
| 179 | revert TranchePool__NotWhiteListed(user); |
| 180 | } |
| 181 | } |
| 182 | |
| 183 | modifier onlyLoanEngine(address user) { |
| 184 | _onlyLoanEngine(user); |
| 185 | _; |
| 186 | } |
| 187 | |
| 188 | function _onlyLoanEngine(address user) internal view { |
| 189 | if (user != loanEngine) { |
| 190 | revert TranchePool__InvalidCaller(user); |
| 191 | } |
| 192 | } |
| 193 | |
| 194 | modifier isWhiteListedForEquityTranche(address user) { |
| 195 | _isWhiteListedForEquityTranche(user); |
| 196 | _; |
| 197 | } |
| 198 | |
| 199 | function _isWhiteListedForEquityTranche(address user) internal view { |
| 200 | if (!whiteListedForEquityTranche[user]) { |
| 201 | revert TranchePool__NotWhiteListedForEquityTranche(user); |
| 202 | } |
| 203 | } |
| 204 | |
| 205 | constructor(address stableCoin_) Ownable(msg.sender) { |
| 206 | s_stableCoin = stableCoin_; |
| 207 | seniorInterestIndex = 1e18; |
| 208 | juniorInterestIndex = 1e18; |
| 209 | equityInterestIndex = 1e18; |
| 210 | } |
| 211 | |
| 212 | function depositSeniorTranche( |
| 213 | uint256 amount |
| 214 | ) external isWhiteListed(msg.sender) { |
| 215 | // q: wy we need a minimum deposit for a tranche? |
| 216 | // a: in book. |
| 217 | if (poolState != PoolState.OPEN) { |
| 218 | revert TranchePool__PoolIsNotOpen(); |
| 219 | } |
| 220 | if (amount == 0) { |
| 221 | revert TranchePool__ZeroValueError(); |
| 222 | } |
| 223 | if (amount < s_minimumDepositAmountSeniorTranche) { |
| 224 | revert TranchePool__LessThanDepositThreshold(amount); |
| 225 | } |
| 226 | // why there is a max cap exists? |
| 227 | // |
| 228 | // 1. to prevent the liquidity from sitting idle |
| 229 | // |
| 230 | if (amount + s_seniorTrancheIdleValue > s_seniorTrancheMaxCap) { |
| 231 | revert TranchePool__MaxDepositCapExceeded( |
| 232 | s_seniorTrancheMaxCap, |
| 233 | amount |
| 234 | ); |
| 235 | } |
| 236 | |
| 237 | // Calculate shares to mint |
| 238 | // invariant: the total shares == idle value because the deposit is allowed only when |
| 239 | // the pool is open and once the pool is moved to a new state new deposits are not allowed |
| 240 | // so what shares == amount holding 1:1 is valid and is not affecting or opening any attack vectors. |
| 241 | uint256 shares = amount; |
| 242 | |
| 243 | IERC20(s_stableCoin).safeTransferFrom( |
| 244 | msg.sender, |
| 245 | address(this), |
| 246 | amount |
| 247 | ); |
| 248 | |
| 249 | s_seniorTrancheShares[msg.sender] += shares; |
| 250 | s_totalSeniorShares += shares; |
| 251 | s_seniorTrancheIdleValue += amount; |
| 252 | seniorUserIndex[msg.sender] = seniorInterestIndex; |
| 253 | s_totalDeposited += amount; |
| 254 | emit FundsDepositedToSeniorTranche( |
| 255 | msg.sender, |
| 256 | amount, |
| 257 | shares, |
| 258 | block.timestamp |
| 259 | ); |
| 260 | } |
| 261 | |
| 262 | function depositJuniorTranche( |
| 263 | uint256 amount |
| 264 | ) external isWhiteListed(msg.sender) { |
| 265 | if (poolState != PoolState.OPEN) { |
| 266 | revert TranchePool__PoolIsNotOpen(); |
| 267 | } |
| 268 | if (amount < s_minimumDepositAmountJuniorTranche) { |
| 269 | revert TranchePool__LessThanDepositThreshold(amount); |
| 270 | } |
| 271 | |
| 272 | if (amount + s_juniorTrancheIdleValue > s_juniorTrancheMaxCap) { |
| 273 | revert TranchePool__MaxDepositCapExceeded( |
| 274 | s_juniorTrancheMaxCap, |
| 275 | amount |
| 276 | ); |
| 277 | } |
| 278 | |
| 279 | uint256 shares = amount; |
| 280 | |
| 281 | IERC20(s_stableCoin).safeTransferFrom( |
| 282 | msg.sender, |
| 283 | address(this), |
| 284 | amount |
| 285 | ); |
| 286 | |
| 287 | s_juniorTrancheShares[msg.sender] += shares; |
| 288 | s_totalJuniorShares += shares; |
| 289 | s_juniorTrancheIdleValue += amount; |
| 290 | juniorUserIndex[msg.sender] = juniorInterestIndex; |
| 291 | s_totalDeposited += amount; |
| 292 | |
| 293 | emit FundsDepositedToJuniorTranche( |
| 294 | msg.sender, |
| 295 | amount, |
| 296 | shares, |
| 297 | block.timestamp |
| 298 | ); |
| 299 | } |
| 300 | |
| 301 | function depositEquityTranche( |
| 302 | uint256 amount |
| 303 | ) external isWhiteListedForEquityTranche(msg.sender) { |
| 304 | if (poolState != PoolState.OPEN) { |
| 305 | revert TranchePool__PoolIsNotOpen(); |
| 306 | } |
| 307 | if (amount < s_minimumDepositAmountEquityTranche) { |
| 308 | revert TranchePool__LessThanDepositThreshold(amount); |
| 309 | } |
| 310 | |
| 311 | if (amount + s_equityTrancheIdleValue > s_equityTrancheMaxCap) { |
| 312 | revert TranchePool__MaxDepositCapExceeded( |
| 313 | s_equityTrancheMaxCap, |
| 314 | amount |
| 315 | ); |
| 316 | } |
| 317 | |
| 318 | uint256 shares = amount; |
| 319 | |
| 320 | IERC20(s_stableCoin).safeTransferFrom( |
| 321 | msg.sender, |
| 322 | address(this), |
| 323 | amount |
| 324 | ); |
| 325 | s_equityTrancheShares[msg.sender] += shares; |
| 326 | s_totalEquityShares += shares; |
| 327 | s_equityTrancheIdleValue += amount; |
| 328 | equityUserIndex[msg.sender] = equityInterestIndex; |
| 329 | s_totalDeposited += amount; |
| 330 | |
| 331 | emit FundsDepositedToEquityTranche( |
| 332 | msg.sender, |
| 333 | amount, |
| 334 | shares, |
| 335 | block.timestamp |
| 336 | ); |
| 337 | } |
| 338 | |
| 339 | /** |
| 340 | * @notice Allocate capital according to the 80/20 split |
| 341 | * @param totalDisbursement Total amount to allocate from the pool |
| 342 | * @param fees Total fees to be collected |
| 343 | */ |
| 344 | function allocateCapital( |
| 345 | uint256 totalDisbursement, |
| 346 | uint256 fees, |
| 347 | address deployer, |
| 348 | address feeManager |
| 349 | ) external onlyLoanEngine(msg.sender) returns (uint256, uint256, uint256) { |
| 350 | if ( |
| 351 | poolState != PoolState.COMMITED && poolState != PoolState.DEPLOYED |
| 352 | ) { |
| 353 | revert TranchePool__PoolIsNotCommited(); |
| 354 | } |
| 355 | |
| 356 | uint256 totalAmount = totalDisbursement + fees; |
| 357 | |
| 358 | // Global liquidity check |
| 359 | uint256 totalIdle = s_seniorTrancheIdleValue + |
| 360 | s_juniorTrancheIdleValue + |
| 361 | s_equityTrancheIdleValue; |
| 362 | |
| 363 | if (totalAmount > totalIdle) { |
| 364 | revert TranchePool__InsufficientLiquidity(); |
| 365 | } |
| 366 | |
| 367 | uint256 targetSenior = (totalAmount * |
| 368 | s_capital_allocation_factor_senior) / 100; |
| 369 | |
| 370 | uint256 targetJunior = (totalAmount * |
| 371 | s_capital_allocation_factor_junior) / 100; |
| 372 | |
| 373 | uint256 targetEquity = totalAmount - targetSenior - targetJunior; |
| 374 | |
| 375 | uint256 seniorAmount = _minimum(targetSenior, s_seniorTrancheIdleValue); |
| 376 | |
| 377 | uint256 juniorAmount = _minimum(targetJunior, s_juniorTrancheIdleValue); |
| 378 | |
| 379 | uint256 equityAmount = _minimum(targetEquity, s_equityTrancheIdleValue); |
| 380 | |
| 381 | uint256 allocated = seniorAmount + juniorAmount + equityAmount; |
| 382 | |
| 383 | uint256 remaining = totalAmount - allocated; |
| 384 | |
| 385 | // Equity absorbs first |
| 386 | if (remaining > 0 && s_equityTrancheIdleValue > equityAmount) { |
| 387 | uint256 extra = _minimum( |
| 388 | remaining, |
| 389 | s_equityTrancheIdleValue - equityAmount |
| 390 | ); |
| 391 | equityAmount += extra; |
| 392 | remaining -= extra; |
| 393 | } |
| 394 | |
| 395 | // Junior absorbs next |
| 396 | if (remaining > 0 && s_juniorTrancheIdleValue > juniorAmount) { |
| 397 | uint256 extra = _minimum( |
| 398 | remaining, |
| 399 | s_juniorTrancheIdleValue - juniorAmount |
| 400 | ); |
| 401 | juniorAmount += extra; |
| 402 | remaining -= extra; |
| 403 | } |
| 404 | |
| 405 | // Senior absorbs last |
| 406 | if (remaining > 0 && s_seniorTrancheIdleValue > seniorAmount) { |
| 407 | uint256 extra = _minimum( |
| 408 | remaining, |
| 409 | s_seniorTrancheIdleValue - seniorAmount |
| 410 | ); |
| 411 | seniorAmount += extra; |
| 412 | remaining -= extra; |
| 413 | } |
| 414 | |
| 415 | // Final safety check |
| 416 | if (remaining > 0) { |
| 417 | revert TranchePool__InsufficientLiquidity(); |
| 418 | } |
| 419 | |
| 420 | if (poolState == PoolState.COMMITED) { |
| 421 | poolState = PoolState.DEPLOYED; |
| 422 | emit PoolStateUpdated(PoolState.DEPLOYED); |
| 423 | } |
| 424 | |
| 425 | s_seniorTrancheIdleValue -= seniorAmount; |
| 426 | s_juniorTrancheIdleValue -= juniorAmount; |
| 427 | s_equityTrancheIdleValue -= equityAmount; |
| 428 | |
| 429 | s_seniorTrancheDeployedValue += seniorAmount; |
| 430 | s_juniorTrancheDeployedValue += juniorAmount; |
| 431 | s_equityTrancheDeployedValue += equityAmount; |
| 432 | |
| 433 | IERC20(s_stableCoin).safeTransfer(deployer, totalDisbursement); |
| 434 | |
| 435 | if (fees > 0) { |
| 436 | IERC20(s_stableCoin).safeTransfer(feeManager, fees); |
| 437 | } |
| 438 | |
| 439 | emit CapitalAllocated( |
| 440 | seniorAmount, |
| 441 | juniorAmount, |
| 442 | equityAmount, |
| 443 | block.timestamp |
| 444 | ); |
| 445 | return (seniorAmount, juniorAmount, equityAmount); |
| 446 | } |
| 447 | |
| 448 | function onInterestAccrued( |
| 449 | uint256 interestAmount, |
| 450 | uint256 seniorInterest, |
| 451 | uint256 juniorInterest |
| 452 | ) external onlyLoanEngine(msg.sender) { |
| 453 | if (interestAmount == 0) return; |
| 454 | |
| 455 | seniorAccruedInterest += seniorInterest; |
| 456 | juniorAccruedInterest += juniorInterest; |
| 457 | equityAccruedInterest += (interestAmount - |
| 458 | seniorInterest - |
| 459 | juniorInterest); |
| 460 | } |
| 461 | |
| 462 | function onRepayment( |
| 463 | uint256 principalRepaid, |
| 464 | uint256 interestRepaid |
| 465 | ) external onlyLoanEngine(msg.sender) { |
| 466 | if (principalRepaid == 0 && interestRepaid == 0) { |
| 467 | revert TranchePool__InvalidTransferAmount(0); |
| 468 | } |
| 469 | |
| 470 | /*////////////////////////////////////////////////////////////// |
| 471 | INTEREST WATERFALL (INDEXED) |
| 472 | //////////////////////////////////////////////////////////////*/ |
| 473 | |
| 474 | uint256 remainingInterest = interestRepaid; |
| 475 | |
| 476 | // 1️⃣ Senior interest |
| 477 | if ( |
| 478 | remainingInterest > 0 && |
| 479 | seniorAccruedInterest > 0 && |
| 480 | s_totalSeniorShares > 0 |
| 481 | ) { |
| 482 | uint256 seniorPaid = _minimum( |
| 483 | remainingInterest, |
| 484 | seniorAccruedInterest |
| 485 | ); |
| 486 | seniorAccruedInterest -= seniorPaid; |
| 487 | seniorInterestIndex += (seniorPaid * 1e18) / s_totalSeniorShares; |
| 488 | remainingInterest -= seniorPaid; |
| 489 | } |
| 490 | |
| 491 | // 2️⃣ Junior interest |
| 492 | if ( |
| 493 | remainingInterest > 0 && |
| 494 | juniorAccruedInterest > 0 && |
| 495 | s_totalJuniorShares > 0 |
| 496 | ) { |
| 497 | uint256 juniorPaid = _minimum( |
| 498 | remainingInterest, |
| 499 | juniorAccruedInterest |
| 500 | ); |
| 501 | juniorAccruedInterest -= juniorPaid; |
| 502 | juniorInterestIndex += (juniorPaid * 1e18) / s_totalJuniorShares; |
| 503 | remainingInterest -= juniorPaid; |
| 504 | } |
| 505 | |
| 506 | // 3️⃣ Equity / overflow interest |
| 507 | if (remainingInterest > 0) { |
| 508 | if (s_totalEquityShares > 0) { |
| 509 | equityInterestIndex += |
| 510 | (remainingInterest * 1e18) / |
| 511 | s_totalEquityShares; |
| 512 | equityAccruedInterest -= _minimum( |
| 513 | equityAccruedInterest, |
| 514 | remainingInterest |
| 515 | ); |
| 516 | } else if (s_totalJuniorShares > 0) { |
| 517 | // no equity → junior gets excess |
| 518 | juniorInterestIndex += |
| 519 | (remainingInterest * 1e18) / |
| 520 | s_totalJuniorShares; |
| 521 | } else { |
| 522 | // no LPs left → protocol revenue |
| 523 | s_protocolRevenue += remainingInterest; |
| 524 | } |
| 525 | } |
| 526 | |
| 527 | /*////////////////////////////////////////////////////////////// |
| 528 | PRINCIPAL REDEMPTION |
| 529 | (REVERSE OF LOSS WATERFALL — NO RATIOS) |
| 530 | //////////////////////////////////////////////////////////////*/ |
| 531 | |
| 532 | if (principalRepaid > 0) { |
| 533 | uint256 remaining = principalRepaid; |
| 534 | |
| 535 | // Senior first (restore safest capital) |
| 536 | if (remaining > 0 && s_seniorTrancheDeployedValue > 0) { |
| 537 | uint256 seniorPay = _minimum( |
| 538 | remaining, |
| 539 | s_seniorTrancheDeployedValue |
| 540 | ); |
| 541 | s_seniorTrancheDeployedValue -= seniorPay; |
| 542 | s_seniorTrancheIdleValue += seniorPay; |
| 543 | remaining -= seniorPay; |
| 544 | } |
| 545 | |
| 546 | // Junior next |
| 547 | if (remaining > 0 && s_juniorTrancheDeployedValue > 0) { |
| 548 | uint256 juniorPay = _minimum( |
| 549 | remaining, |
| 550 | s_juniorTrancheDeployedValue |
| 551 | ); |
| 552 | s_juniorTrancheDeployedValue -= juniorPay; |
| 553 | s_juniorTrancheIdleValue += juniorPay; |
| 554 | remaining -= juniorPay; |
| 555 | } |
| 556 | |
| 557 | // Equity last |
| 558 | if (remaining > 0 && s_equityTrancheDeployedValue > 0) { |
| 559 | uint256 equityPay = _minimum( |
| 560 | remaining, |
| 561 | s_equityTrancheDeployedValue |
| 562 | ); |
| 563 | s_equityTrancheDeployedValue -= equityPay; |
| 564 | s_equityTrancheIdleValue += equityPay; |
| 565 | remaining -= equityPay; |
| 566 | } |
| 567 | |
| 568 | // Safety: should never happen unless LoanEngine lies |
| 569 | if (remaining > 0) { |
| 570 | revert TranchePool__PrincipalRepaymentExceeded(); |
| 571 | } |
| 572 | } |
| 573 | } |
| 574 | |
| 575 | // lp profit withdrawal is pending but it can only be implemented |
| 576 | // after the loan enginge implementation which determines how the |
| 577 | // interest will be accured and the distribution is dependent on the |
| 578 | // share capacity |
| 579 | |
| 580 | function onLoss( |
| 581 | uint256 principalLoss, |
| 582 | uint256 interestAccrued |
| 583 | ) external onlyLoanEngine(msg.sender) { |
| 584 | if (principalLoss == 0 && interestAccrued == 0) { |
| 585 | revert TranchePool__ZeroValueError(); |
| 586 | } |
| 587 | |
| 588 | /*////////////////////////////////////////////////////////////// |
| 589 | 1️⃣ CANCEL GHOST INTEREST |
| 590 | (SAME PRIORITY AS INTEREST PAYOUT) |
| 591 | //////////////////////////////////////////////////////////////*/ |
| 592 | |
| 593 | uint256 remainingInterest = interestAccrued; |
| 594 | |
| 595 | // Cancel senior accrued interest first |
| 596 | if (remainingInterest > 0 && seniorAccruedInterest > 0) { |
| 597 | uint256 seniorCancel = _minimum( |
| 598 | remainingInterest, |
| 599 | seniorAccruedInterest |
| 600 | ); |
| 601 | seniorAccruedInterest -= seniorCancel; |
| 602 | remainingInterest -= seniorCancel; |
| 603 | } |
| 604 | |
| 605 | // Then junior |
| 606 | if (remainingInterest > 0 && juniorAccruedInterest > 0) { |
| 607 | uint256 juniorCancel = _minimum( |
| 608 | remainingInterest, |
| 609 | juniorAccruedInterest |
| 610 | ); |
| 611 | juniorAccruedInterest -= juniorCancel; |
| 612 | remainingInterest -= juniorCancel; |
| 613 | } |
| 614 | |
| 615 | // Any remaining interest is ignored (equity / protocol had no promise) |
| 616 | |
| 617 | /*////////////////////////////////////////////////////////////// |
| 618 | 2️⃣ PRINCIPAL LOSS WATERFALL |
| 619 | Equity → Junior → Senior |
| 620 | //////////////////////////////////////////////////////////////*/ |
| 621 | |
| 622 | s_totalLoss += principalLoss; |
| 623 | uint256 remaining = principalLoss; |
| 624 | |
| 625 | uint256 equityLoss; |
| 626 | uint256 juniorLoss; |
| 627 | uint256 seniorLoss; |
| 628 | |
| 629 | // Equity absorbs first |
| 630 | if (remaining > 0 && s_equityTrancheDeployedValue > 0) { |
| 631 | equityLoss = _minimum(remaining, s_equityTrancheDeployedValue); |
| 632 | s_equityTrancheDeployedValue -= equityLoss; |
| 633 | equityPrincipalShortfall += equityLoss; |
| 634 | remaining -= equityLoss; |
| 635 | } |
| 636 | |
| 637 | // Junior next |
| 638 | if (remaining > 0 && s_juniorTrancheDeployedValue > 0) { |
| 639 | juniorLoss = _minimum(remaining, s_juniorTrancheDeployedValue); |
| 640 | s_juniorTrancheDeployedValue -= juniorLoss; |
| 641 | juniorPrincipalShortfall += juniorLoss; |
| 642 | remaining -= juniorLoss; |
| 643 | } |
| 644 | |
| 645 | // Senior last |
| 646 | if (remaining > 0 && s_seniorTrancheDeployedValue > 0) { |
| 647 | seniorLoss = _minimum(remaining, s_seniorTrancheDeployedValue); |
| 648 | s_seniorTrancheDeployedValue -= seniorLoss; |
| 649 | seniorPrincipalShortfall += seniorLoss; |
| 650 | remaining -= seniorLoss; |
| 651 | } |
| 652 | |
| 653 | if (remaining > 0) { |
| 654 | revert TranchePool__LossExceededCapital(remaining); |
| 655 | } |
| 656 | |
| 657 | emit LossAllocated(seniorLoss, juniorLoss, equityLoss); |
| 658 | } |
| 659 | |
| 660 | // on recovery what happens is the protocol may recover more than he lost and it can cause appreciation of the share value when withdrawing, keeping the design simple because adding it to interest accured make no difference at the end of withdrawing. |
| 661 | |
| 662 | function onRecovery(uint256 amount) external onlyLoanEngine(msg.sender) { |
| 663 | if (amount == 0) { |
| 664 | revert TranchePool__ZeroValueError(); |
| 665 | } |
| 666 | |
| 667 | s_totalRecovered += amount; |
| 668 | uint256 remaining = amount; |
| 669 | |
| 670 | // Senior first |
| 671 | if (remaining > 0 && seniorPrincipalShortfall > 0) { |
| 672 | uint256 seniorPay = _minimum(remaining, seniorPrincipalShortfall); |
| 673 | seniorPrincipalShortfall -= seniorPay; |
| 674 | s_seniorTrancheIdleValue += seniorPay; |
| 675 | remaining -= seniorPay; |
| 676 | } |
| 677 | |
| 678 | // Junior next |
| 679 | if (remaining > 0 && juniorPrincipalShortfall > 0) { |
| 680 | uint256 juniorPay = _minimum(remaining, juniorPrincipalShortfall); |
| 681 | juniorPrincipalShortfall -= juniorPay; |
| 682 | s_juniorTrancheIdleValue += juniorPay; |
| 683 | remaining -= juniorPay; |
| 684 | } |
| 685 | |
| 686 | // Equity last |
| 687 | if (remaining > 0 && equityPrincipalShortfall > 0) { |
| 688 | uint256 equityPay = _minimum(remaining, equityPrincipalShortfall); |
| 689 | equityPrincipalShortfall -= equityPay; |
| 690 | s_equityTrancheIdleValue += equityPay; |
| 691 | remaining -= equityPay; |
| 692 | } |
| 693 | |
| 694 | // Any excess is true upside → equity |
| 695 | if (remaining > 0) { |
| 696 | s_equityTrancheIdleValue += remaining; |
| 697 | } |
| 698 | |
| 699 | emit RecoverAmountTransferredToTranchePool(amount, block.timestamp); |
| 700 | } |
| 701 | |
| 702 | // when the pool closes if the user withdraw the shares before claiming interest on those he will lose the interest for the withdrawn shares |
| 703 | function claimSeniorInterest() external { |
| 704 | uint256 userShares = s_seniorTrancheShares[msg.sender]; |
| 705 | if (userShares == 0) revert TranchePool__InsufficientShares(); |
| 706 | |
| 707 | uint256 indexDelta = seniorInterestIndex - seniorUserIndex[msg.sender]; |
| 708 | |
| 709 | if (indexDelta == 0) revert TranchePool__ZeroWithdrawal(); |
| 710 | |
| 711 | uint256 claimable = (userShares * indexDelta) / 1e18; |
| 712 | |
| 713 | // CHANGED: update user index BEFORE transfer |
| 714 | seniorUserIndex[msg.sender] = seniorInterestIndex; |
| 715 | |
| 716 | IERC20(s_stableCoin).safeTransfer(msg.sender, claimable); |
| 717 | } |
| 718 | |
| 719 | function claimJuniorInterest() external { |
| 720 | uint256 userShares = s_juniorTrancheShares[msg.sender]; |
| 721 | if (userShares == 0) revert TranchePool__InsufficientShares(); |
| 722 | |
| 723 | uint256 indexDelta = juniorInterestIndex - juniorUserIndex[msg.sender]; |
| 724 | |
| 725 | if (indexDelta == 0) revert TranchePool__ZeroWithdrawal(); |
| 726 | |
| 727 | uint256 claimable = (userShares * indexDelta) / 1e18; |
| 728 | |
| 729 | // CHANGED: update user index BEFORE transfer |
| 730 | juniorUserIndex[msg.sender] = juniorInterestIndex; |
| 731 | |
| 732 | IERC20(s_stableCoin).safeTransfer(msg.sender, claimable); |
| 733 | } |
| 734 | |
| 735 | function claimEquityInterest() |
| 736 | external |
| 737 | isWhiteListedForEquityTranche(msg.sender) |
| 738 | { |
| 739 | uint256 userShares = s_equityTrancheShares[msg.sender]; |
| 740 | if (userShares == 0) revert TranchePool__InsufficientShares(); |
| 741 | |
| 742 | uint256 indexDelta = equityInterestIndex - equityUserIndex[msg.sender]; |
| 743 | |
| 744 | if (indexDelta == 0) revert TranchePool__ZeroWithdrawal(); |
| 745 | |
| 746 | uint256 claimable = (userShares * indexDelta) / 1e18; |
| 747 | |
| 748 | // CHANGED: update user index BEFORE transfer |
| 749 | equityUserIndex[msg.sender] = equityInterestIndex; |
| 750 | |
| 751 | IERC20(s_stableCoin).safeTransfer(msg.sender, claimable); |
| 752 | } |
| 753 | |
| 754 | /** |
| 755 | * |
| 756 | * |
| 757 | * @notice Withdraw from senior tranche by burning shares |
| 758 | * @param shares Number of shares to burn (0 = withdraw all) |
| 759 | * passing zero amount will cause the burn of all shares |
| 760 | */ |
| 761 | function withdrawSeniorTranche( |
| 762 | uint256 shares |
| 763 | ) external isWhiteListed(msg.sender) { |
| 764 | if (poolState != PoolState.OPEN && poolState != PoolState.CLOSED) { |
| 765 | revert TranchePool__WithdrawNotAllowed(poolState); |
| 766 | } |
| 767 | uint256 userShares = s_seniorTrancheShares[msg.sender]; |
| 768 | |
| 769 | if (userShares == 0) { |
| 770 | revert TranchePool__InsufficientShares(); |
| 771 | } |
| 772 | |
| 773 | // If shares is 0, withdraw everything |
| 774 | uint256 sharesToBurn = shares == 0 ? userShares : shares; |
| 775 | |
| 776 | if (sharesToBurn > userShares) { |
| 777 | revert TranchePool__InsufficientShares(); |
| 778 | } |
| 779 | |
| 780 | // Calculate amount to withdraw based on current pool value |
| 781 | uint256 amountToWithdraw = (sharesToBurn * s_seniorTrancheIdleValue) / |
| 782 | s_totalSeniorShares; |
| 783 | |
| 784 | if (seniorUserIndex[msg.sender] != seniorInterestIndex) { |
| 785 | revert TranchePool__InterestNotClaimed(); |
| 786 | } |
| 787 | |
| 788 | if (amountToWithdraw == 0) { |
| 789 | revert TranchePool__ZeroWithdrawal(); |
| 790 | } |
| 791 | |
| 792 | if (amountToWithdraw > s_seniorTrancheIdleValue) { |
| 793 | revert TranchePool__InsufficientLiquidity(); |
| 794 | } |
| 795 | |
| 796 | // Update state before transfer (CEI pattern) |
| 797 | s_seniorTrancheShares[msg.sender] -= sharesToBurn; |
| 798 | s_totalSeniorShares -= sharesToBurn; |
| 799 | s_seniorTrancheIdleValue -= amountToWithdraw; |
| 800 | s_totalDeposited -= amountToWithdraw; |
| 801 | // Transfer tokens |
| 802 | IERC20(s_stableCoin).safeTransfer(msg.sender, amountToWithdraw); |
| 803 | |
| 804 | emit WithdrawnFromSeniorTranche( |
| 805 | msg.sender, |
| 806 | amountToWithdraw, |
| 807 | sharesToBurn, |
| 808 | block.timestamp |
| 809 | ); |
| 810 | } |
| 811 | |
| 812 | /** |
| 813 | * @notice Withdraw from junior tranche by burning shares |
| 814 | * @param shares Number of shares to burn (0 = withdraw all) |
| 815 | */ |
| 816 | function withdrawJuniorTranche( |
| 817 | uint256 shares |
| 818 | ) external isWhiteListed(msg.sender) { |
| 819 | if (poolState != PoolState.OPEN && poolState != PoolState.CLOSED) { |
| 820 | revert TranchePool__WithdrawNotAllowed(poolState); |
| 821 | } |
| 822 | uint256 userShares = s_juniorTrancheShares[msg.sender]; |
| 823 | |
| 824 | if (userShares == 0) { |
| 825 | revert TranchePool__InsufficientShares(); |
| 826 | } |
| 827 | |
| 828 | if (juniorUserIndex[msg.sender] != juniorInterestIndex) { |
| 829 | revert TranchePool__InterestNotClaimed(); |
| 830 | } |
| 831 | |
| 832 | uint256 sharesToBurn = shares == 0 ? userShares : shares; |
| 833 | |
| 834 | if (sharesToBurn > userShares) { |
| 835 | revert TranchePool__InsufficientShares(); |
| 836 | } |
| 837 | |
| 838 | uint256 amountToWithdraw = (sharesToBurn * s_juniorTrancheIdleValue) / |
| 839 | s_totalJuniorShares; |
| 840 | |
| 841 | if (amountToWithdraw == 0) { |
| 842 | revert TranchePool__ZeroWithdrawal(); |
| 843 | } |
| 844 | if (amountToWithdraw > s_juniorTrancheIdleValue) { |
| 845 | revert TranchePool__InsufficientLiquidity(); |
| 846 | } |
| 847 | |
| 848 | s_juniorTrancheShares[msg.sender] -= sharesToBurn; |
| 849 | s_totalJuniorShares -= sharesToBurn; |
| 850 | s_juniorTrancheIdleValue -= amountToWithdraw; |
| 851 | s_totalDeposited -= amountToWithdraw; |
| 852 | |
| 853 | IERC20(s_stableCoin).safeTransfer(msg.sender, amountToWithdraw); |
| 854 | |
| 855 | emit WithdrawnFromJuniorTranche( |
| 856 | msg.sender, |
| 857 | amountToWithdraw, |
| 858 | sharesToBurn, |
| 859 | block.timestamp |
| 860 | ); |
| 861 | } |
| 862 | |
| 863 | function withdrawEquityTranche( |
| 864 | uint256 shares |
| 865 | ) external isWhiteListedForEquityTranche(msg.sender) { |
| 866 | if (poolState != PoolState.OPEN && poolState != PoolState.CLOSED) { |
| 867 | revert TranchePool__WithdrawNotAllowed(poolState); |
| 868 | } |
| 869 | uint256 userShares = s_equityTrancheShares[msg.sender]; |
| 870 | |
| 871 | if (userShares == 0) { |
| 872 | revert TranchePool__InsufficientShares(); |
| 873 | } |
| 874 | if (equityUserIndex[msg.sender] != equityInterestIndex) { |
| 875 | revert TranchePool__InterestNotClaimed(); |
| 876 | } |
| 877 | uint256 sharesToBurn = shares == 0 ? userShares : shares; |
| 878 | if (sharesToBurn > userShares) { |
| 879 | revert TranchePool__InsufficientShares(); |
| 880 | } |
| 881 | |
| 882 | uint256 amountToWithdraw = (sharesToBurn * s_equityTrancheIdleValue) / |
| 883 | s_totalEquityShares; |
| 884 | |
| 885 | if (amountToWithdraw == 0) { |
| 886 | revert TranchePool__ZeroWithdrawal(); |
| 887 | } |
| 888 | if (amountToWithdraw > s_equityTrancheIdleValue) { |
| 889 | revert TranchePool__InsufficientLiquidity(); |
| 890 | } |
| 891 | s_equityTrancheShares[msg.sender] -= sharesToBurn; |
| 892 | s_totalEquityShares -= sharesToBurn; |
| 893 | s_equityTrancheIdleValue -= amountToWithdraw; |
| 894 | s_totalDeposited -= amountToWithdraw; |
| 895 | |
| 896 | IERC20(s_stableCoin).safeTransfer(msg.sender, amountToWithdraw); |
| 897 | |
| 898 | emit WithdrawnFromEquityTranche( |
| 899 | msg.sender, |
| 900 | amountToWithdraw, |
| 901 | sharesToBurn, |
| 902 | block.timestamp |
| 903 | ); |
| 904 | } |
| 905 | |
| 906 | /** |
| 907 | * @notice Withdraw specific amount from senior tranche |
| 908 | * @param amount Amount of tokens to withdraw |
| 909 | */ |
| 910 | function withdrawSeniorTrancheByAmount( |
| 911 | uint256 amount |
| 912 | ) external isWhiteListed(msg.sender) { |
| 913 | if (poolState != PoolState.OPEN && poolState != PoolState.CLOSED) { |
| 914 | revert TranchePool__WithdrawNotAllowed(poolState); |
| 915 | } |
| 916 | if (amount == 0) { |
| 917 | revert TranchePool__ZeroWithdrawal(); |
| 918 | } |
| 919 | if (seniorUserIndex[msg.sender] != seniorInterestIndex) { |
| 920 | revert TranchePool__InterestNotClaimed(); |
| 921 | } |
| 922 | |
| 923 | uint256 userBalance = getSeniorTrancheBalance(msg.sender); |
| 924 | |
| 925 | if (amount > userBalance) { |
| 926 | revert TranchePool__InsufficientShares(); |
| 927 | } |
| 928 | |
| 929 | if (amount > s_seniorTrancheIdleValue) { |
| 930 | revert TranchePool__InsufficientLiquidity(); |
| 931 | } |
| 932 | |
| 933 | // Calculate shares to burn for this amount |
| 934 | uint256 sharesToBurn = (amount * s_totalSeniorShares) / |
| 935 | (s_seniorTrancheIdleValue); |
| 936 | |
| 937 | // Handle rounding - ensure we don't try to withdraw more than available |
| 938 | if (sharesToBurn > s_seniorTrancheShares[msg.sender]) { |
| 939 | sharesToBurn = s_seniorTrancheShares[msg.sender]; |
| 940 | } |
| 941 | |
| 942 | s_seniorTrancheShares[msg.sender] -= sharesToBurn; |
| 943 | s_totalSeniorShares -= sharesToBurn; |
| 944 | s_seniorTrancheIdleValue -= amount; |
| 945 | s_totalDeposited -= amount; |
| 946 | |
| 947 | IERC20(s_stableCoin).safeTransfer(msg.sender, amount); |
| 948 | |
| 949 | emit WithdrawnFromSeniorTranche( |
| 950 | msg.sender, |
| 951 | amount, |
| 952 | sharesToBurn, |
| 953 | block.timestamp |
| 954 | ); |
| 955 | } |
| 956 | |
| 957 | /** |
| 958 | * @notice Withdraw specific amount from junior tranche |
| 959 | * @param amount Amount of tokens to withdraw |
| 960 | */ |
| 961 | function withdrawJuniorTrancheByAmount( |
| 962 | uint256 amount |
| 963 | ) external isWhiteListed(msg.sender) { |
| 964 | if (poolState != PoolState.OPEN && poolState != PoolState.CLOSED) { |
| 965 | revert TranchePool__WithdrawNotAllowed(poolState); |
| 966 | } |
| 967 | if (amount == 0) { |
| 968 | revert TranchePool__ZeroWithdrawal(); |
| 969 | } |
| 970 | |
| 971 | if (juniorUserIndex[msg.sender] != juniorInterestIndex) { |
| 972 | revert TranchePool__InterestNotClaimed(); |
| 973 | } |
| 974 | |
| 975 | uint256 userBalance = getJuniorTrancheBalance(msg.sender); |
| 976 | |
| 977 | if (amount > userBalance) { |
| 978 | revert TranchePool__InsufficientShares(); |
| 979 | } |
| 980 | |
| 981 | if (amount > s_juniorTrancheIdleValue) { |
| 982 | revert TranchePool__InsufficientLiquidity(); |
| 983 | } |
| 984 | |
| 985 | uint256 sharesToBurn = (amount * s_totalJuniorShares) / |
| 986 | (s_juniorTrancheIdleValue); |
| 987 | |
| 988 | if (sharesToBurn > s_juniorTrancheShares[msg.sender]) { |
| 989 | sharesToBurn = s_juniorTrancheShares[msg.sender]; |
| 990 | } |
| 991 | |
| 992 | s_juniorTrancheShares[msg.sender] -= sharesToBurn; |
| 993 | s_totalJuniorShares -= sharesToBurn; |
| 994 | s_juniorTrancheIdleValue -= amount; |
| 995 | s_totalDeposited -= amount; |
| 996 | |
| 997 | IERC20(s_stableCoin).safeTransfer(msg.sender, amount); |
| 998 | |
| 999 | emit WithdrawnFromJuniorTranche( |
| 1000 | msg.sender, |
| 1001 | amount, |
| 1002 | sharesToBurn, |
| 1003 | block.timestamp |
| 1004 | ); |
| 1005 | } |
| 1006 | |
| 1007 | function withdrawEquityTrancheByAmount( |
| 1008 | uint256 amount |
| 1009 | ) external isWhiteListedForEquityTranche(msg.sender) { |
| 1010 | if (poolState != PoolState.OPEN && poolState != PoolState.CLOSED) { |
| 1011 | revert TranchePool__WithdrawNotAllowed(poolState); |
| 1012 | } |
| 1013 | if (amount == 0) { |
| 1014 | revert TranchePool__ZeroWithdrawal(); |
| 1015 | } |
| 1016 | |
| 1017 | if (equityUserIndex[msg.sender] != equityInterestIndex) { |
| 1018 | revert TranchePool__InterestNotClaimed(); |
| 1019 | } |
| 1020 | |
| 1021 | uint256 userBalance = getEquityTrancheBalance(msg.sender); |
| 1022 | |
| 1023 | if (amount > userBalance) { |
| 1024 | revert TranchePool__InsufficientShares(); |
| 1025 | } |
| 1026 | |
| 1027 | if (amount > s_equityTrancheIdleValue) { |
| 1028 | revert TranchePool__InsufficientLiquidity(); |
| 1029 | } |
| 1030 | |
| 1031 | uint256 sharesToBurn = (amount * s_totalEquityShares) / |
| 1032 | (s_equityTrancheIdleValue); |
| 1033 | |
| 1034 | if (sharesToBurn > s_equityTrancheShares[msg.sender]) { |
| 1035 | sharesToBurn = s_equityTrancheShares[msg.sender]; |
| 1036 | } |
| 1037 | |
| 1038 | s_equityTrancheShares[msg.sender] -= sharesToBurn; |
| 1039 | s_totalEquityShares -= sharesToBurn; |
| 1040 | s_equityTrancheIdleValue -= amount; |
| 1041 | s_totalDeposited -= amount; |
| 1042 | |
| 1043 | IERC20(s_stableCoin).safeTransfer(msg.sender, amount); |
| 1044 | |
| 1045 | emit WithdrawnFromEquityTranche( |
| 1046 | msg.sender, |
| 1047 | amount, |
| 1048 | sharesToBurn, |
| 1049 | block.timestamp |
| 1050 | ); |
| 1051 | } |
| 1052 | |
| 1053 | /** |
| 1054 | * @notice Get the current balance of a user in the senior tranche |
| 1055 | */ |
| 1056 | function getSeniorTrancheBalance( |
| 1057 | address user |
| 1058 | ) public view returns (uint256) { |
| 1059 | if (s_totalSeniorShares == 0) return 0; |
| 1060 | return |
| 1061 | (s_seniorTrancheShares[user] * s_seniorTrancheIdleValue) / |
| 1062 | s_totalSeniorShares; |
| 1063 | } |
| 1064 | |
| 1065 | /** |
| 1066 | * @notice Get the current balance of a user in the junior tranche |
| 1067 | */ |
| 1068 | function getJuniorTrancheBalance( |
| 1069 | address user |
| 1070 | ) public view returns (uint256) { |
| 1071 | if (s_totalJuniorShares == 0) return 0; |
| 1072 | return |
| 1073 | (s_juniorTrancheShares[user] * s_juniorTrancheIdleValue) / |
| 1074 | s_totalJuniorShares; |
| 1075 | } |
| 1076 | |
| 1077 | function getEquityTrancheBalance( |
| 1078 | address user |
| 1079 | ) public view returns (uint256) { |
| 1080 | if (s_totalEquityShares == 0) return 0; |
| 1081 | return |
| 1082 | (s_equityTrancheShares[user] * s_equityTrancheIdleValue) / |
| 1083 | s_totalEquityShares; |
| 1084 | } |
| 1085 | |
| 1086 | // Admin functions |
| 1087 | function setMinimumDepositAmountJuniorTranche( |
| 1088 | uint256 amount |
| 1089 | ) external onlyOwner { |
| 1090 | if (amount > s_juniorTrancheMaxCap) { |
| 1091 | revert TranchePool__InvalidMinDepositAmount(); |
| 1092 | } |
| 1093 | s_minimumDepositAmountJuniorTranche = amount; |
| 1094 | } |
| 1095 | |
| 1096 | function setMinimumDepositAmountSeniorTranche( |
| 1097 | uint256 amount |
| 1098 | ) external onlyOwner { |
| 1099 | if (amount > s_seniorTrancheMaxCap) { |
| 1100 | revert TranchePool__InvalidMinDepositAmount(); |
| 1101 | } |
| 1102 | s_minimumDepositAmountSeniorTranche = amount; |
| 1103 | } |
| 1104 | |
| 1105 | function setMinimumDepositAmountEquityTranche( |
| 1106 | uint256 amount |
| 1107 | ) external onlyOwner { |
| 1108 | if (amount > s_equityTrancheMaxCap) { |
| 1109 | revert TranchePool__InvalidMinDepositAmount(); |
| 1110 | } |
| 1111 | s_minimumDepositAmountEquityTranche = amount; |
| 1112 | } |
| 1113 | |
| 1114 | function setTrancheCapitalAllocationFactorSenior( |
| 1115 | uint256 factor |
| 1116 | ) external onlyOwner { |
| 1117 | if (factor + s_capital_allocation_factor_junior > 100) |
| 1118 | revert TranchePool__InvalidAllocationRatio(); |
| 1119 | s_capital_allocation_factor_senior = factor; |
| 1120 | emit CapitalAllocationFactorUpdatedSenior(factor); |
| 1121 | } |
| 1122 | |
| 1123 | function setTrancheCapitalAllocationFactorJunior( |
| 1124 | uint256 factor |
| 1125 | ) external onlyOwner { |
| 1126 | if (factor + s_capital_allocation_factor_senior > 100) |
| 1127 | revert TranchePool__InvalidAllocationRatio(); |
| 1128 | s_capital_allocation_factor_junior = factor; |
| 1129 | emit CapitalAllocationFactorUpdatedJunior(factor); |
| 1130 | } |
| 1131 | |
| 1132 | function setSeniorAPR(uint256 apr) external onlyOwner { |
| 1133 | if (apr == 0) { |
| 1134 | revert TranchePool__ZeroAPRError(); |
| 1135 | } |
| 1136 | s_senior_apr = apr; |
| 1137 | } |
| 1138 | |
| 1139 | function setTargetJuniorAPR(uint256 apr) external onlyOwner { |
| 1140 | if (apr == 0) { |
| 1141 | revert TranchePool__ZeroAPRError(); |
| 1142 | } |
| 1143 | s_target_junior_apr = apr; |
| 1144 | } |
| 1145 | |
| 1146 | function setPoolState(PoolState newState) external onlyOwner { |
| 1147 | if (uint256(newState) < uint256(poolState)) { |
| 1148 | revert TranchePool__InvalidStateTransition(newState); |
| 1149 | } |
| 1150 | |
| 1151 | if (newState == PoolState.CLOSED) { |
| 1152 | if (getTotalDeployedValue() > 0) { |
| 1153 | revert TranchePool__DeployedCapitalExists(); |
| 1154 | } |
| 1155 | } |
| 1156 | |
| 1157 | poolState = newState; |
| 1158 | |
| 1159 | emit PoolStateUpdated(newState); |
| 1160 | } |
| 1161 | |
| 1162 | function setLoanEngine(address _loanEngine) external onlyOwner { |
| 1163 | if (_loanEngine == address(0)) { |
| 1164 | revert TranchePool__ZeroAddressError(); |
| 1165 | } |
| 1166 | loanEngine = _loanEngine; |
| 1167 | } |
| 1168 | |
| 1169 | function setMaxAllocationCapSeniorTranche( |
| 1170 | uint256 amount |
| 1171 | ) external onlyOwner { |
| 1172 | if (amount == 0) { |
| 1173 | revert TranchePool__ZeroValueError(); |
| 1174 | } |
| 1175 | if (amount < s_minimumDepositAmountSeniorTranche) { |
| 1176 | revert TranchePool__InvalidMaxCapAmount(); |
| 1177 | } |
| 1178 | s_seniorTrancheMaxCap = amount; |
| 1179 | } |
| 1180 | |
| 1181 | function setMaxAllocationCapJuniorTranche( |
| 1182 | uint256 amount |
| 1183 | ) external onlyOwner { |
| 1184 | if (amount == 0) { |
| 1185 | revert TranchePool__ZeroValueError(); |
| 1186 | } |
| 1187 | if (amount < s_minimumDepositAmountJuniorTranche) { |
| 1188 | revert TranchePool__InvalidMaxCapAmount(); |
| 1189 | } |
| 1190 | s_juniorTrancheMaxCap = amount; |
| 1191 | } |
| 1192 | |
| 1193 | function setMaxAllocationCapEquityTranche( |
| 1194 | uint256 amount |
| 1195 | ) external onlyOwner { |
| 1196 | if (amount == 0) { |
| 1197 | revert TranchePool__ZeroValueError(); |
| 1198 | } |
| 1199 | if (amount < s_minimumDepositAmountEquityTranche) { |
| 1200 | revert TranchePool__InvalidMaxCapAmount(); |
| 1201 | } |
| 1202 | s_equityTrancheMaxCap = amount; |
| 1203 | } |
| 1204 | |
| 1205 | function updateWhitelist(address user, bool status) external onlyOwner { |
| 1206 | whiteListedLps[user] = status; |
| 1207 | } |
| 1208 | |
| 1209 | function updateEquityTrancheWhiteList( |
| 1210 | address user, |
| 1211 | bool status |
| 1212 | ) external onlyOwner { |
| 1213 | whiteListedForEquityTranche[user] = status; |
| 1214 | } |
| 1215 | |
| 1216 | function _minimum(uint256 a, uint256 b) internal pure returns (uint256) { |
| 1217 | if (a > b) { |
| 1218 | return b; |
| 1219 | } else { |
| 1220 | return a; |
| 1221 | } |
| 1222 | } |
| 1223 | |
| 1224 | // getters |
| 1225 | |
| 1226 | function getSeniorTrancheMaxDepositCap() external view returns (uint256) { |
| 1227 | return s_seniorTrancheMaxCap; |
| 1228 | } |
| 1229 | |
| 1230 | function getSeniorTrancheMinimumDepositAmount() |
| 1231 | external |
| 1232 | view |
| 1233 | returns (uint256) |
| 1234 | { |
| 1235 | return s_minimumDepositAmountSeniorTranche; |
| 1236 | } |
| 1237 | |
| 1238 | function getSeniorTrancheShares( |
| 1239 | address user |
| 1240 | ) external view returns (uint256) { |
| 1241 | return s_seniorTrancheShares[user]; |
| 1242 | } |
| 1243 | |
| 1244 | function getTotalSeniorShares() external view returns (uint256) { |
| 1245 | return s_totalSeniorShares; |
| 1246 | } |
| 1247 | |
| 1248 | function getSeniorTrancheIdleValue() external view returns (uint256) { |
| 1249 | return s_seniorTrancheIdleValue; |
| 1250 | } |
| 1251 | |
| 1252 | function getSeniorTrancheDeployedValue() external view returns (uint256) { |
| 1253 | return s_seniorTrancheDeployedValue; |
| 1254 | } |
| 1255 | |
| 1256 | function getSeniorInterestIndex() external view returns (uint256) { |
| 1257 | return seniorInterestIndex; |
| 1258 | } |
| 1259 | |
| 1260 | function getSeniorUserIndex(address user) external view returns (uint256) { |
| 1261 | return seniorUserIndex[user]; |
| 1262 | } |
| 1263 | |
| 1264 | function getJuniorTrancheMaxDepositCap() external view returns (uint256) { |
| 1265 | return s_juniorTrancheMaxCap; |
| 1266 | } |
| 1267 | |
| 1268 | function getJuniorInterestIndex() external view returns (uint256) { |
| 1269 | return juniorInterestIndex; |
| 1270 | } |
| 1271 | |
| 1272 | function getJuniorTrancheMinimumDepositAmount() |
| 1273 | external |
| 1274 | view |
| 1275 | returns (uint256) |
| 1276 | { |
| 1277 | return s_minimumDepositAmountJuniorTranche; |
| 1278 | } |
| 1279 | |
| 1280 | function getJuniorTrancheShares( |
| 1281 | address user |
| 1282 | ) external view returns (uint256) { |
| 1283 | return s_juniorTrancheShares[user]; |
| 1284 | } |
| 1285 | |
| 1286 | function getTotalJuniorShares() external view returns (uint256) { |
| 1287 | return s_totalJuniorShares; |
| 1288 | } |
| 1289 | |
| 1290 | function getJuniorTrancheIdleValue() external view returns (uint256) { |
| 1291 | return s_juniorTrancheIdleValue; |
| 1292 | } |
| 1293 | |
| 1294 | function getJuniorTrancheDeployedValue() external view returns (uint256) { |
| 1295 | return s_juniorTrancheDeployedValue; |
| 1296 | } |
| 1297 | |
| 1298 | function getJuniorUserIndex(address user) external view returns (uint256) { |
| 1299 | return juniorUserIndex[user]; |
| 1300 | } |
| 1301 | |
| 1302 | function getEquityTrancheMaxDepositCap() external view returns (uint256) { |
| 1303 | return s_equityTrancheMaxCap; |
| 1304 | } |
| 1305 | |
| 1306 | function getEquityTrancheShares( |
| 1307 | address user |
| 1308 | ) external view returns (uint256) { |
| 1309 | return s_equityTrancheShares[user]; |
| 1310 | } |
| 1311 | |
| 1312 | function getTotalEquityShares() external view returns (uint256) { |
| 1313 | return s_totalEquityShares; |
| 1314 | } |
| 1315 | |
| 1316 | function getEquityTrancheMinimumDepositAmount() |
| 1317 | external |
| 1318 | view |
| 1319 | returns (uint256) |
| 1320 | { |
| 1321 | return s_minimumDepositAmountEquityTranche; |
| 1322 | } |
| 1323 | |
| 1324 | function getEquityTrancheIdleValue() external view returns (uint256) { |
| 1325 | return s_equityTrancheIdleValue; |
| 1326 | } |
| 1327 | |
| 1328 | function getEquityTrancheDeployedValue() external view returns (uint256) { |
| 1329 | return s_equityTrancheDeployedValue; |
| 1330 | } |
| 1331 | |
| 1332 | function getEquityInterestIndex() external view returns (uint256) { |
| 1333 | return equityInterestIndex; |
| 1334 | } |
| 1335 | |
| 1336 | function getEquityUserIndex(address user) external view returns (uint256) { |
| 1337 | return equityUserIndex[user]; |
| 1338 | } |
| 1339 | |
| 1340 | function getPoolState() external view returns (PoolState) { |
| 1341 | return poolState; |
| 1342 | } |
| 1343 | |
| 1344 | function getTotalDeployedValue() public view returns (uint256) { |
| 1345 | return |
| 1346 | s_seniorTrancheDeployedValue + |
| 1347 | s_juniorTrancheDeployedValue + |
| 1348 | s_equityTrancheDeployedValue; |
| 1349 | } |
| 1350 | |
| 1351 | function getTotalIdleValue() external view returns (uint256) { |
| 1352 | return |
| 1353 | s_seniorTrancheIdleValue + |
| 1354 | s_juniorTrancheIdleValue + |
| 1355 | s_equityTrancheIdleValue; |
| 1356 | } |
| 1357 | |
| 1358 | function getSeniorAllocationRatio() external view returns (uint256) { |
| 1359 | return s_capital_allocation_factor_senior; |
| 1360 | } |
| 1361 | |
| 1362 | function getJuniorAllocationRatio() external view returns (uint256) { |
| 1363 | return s_capital_allocation_factor_junior; |
| 1364 | } |
| 1365 | |
| 1366 | function getTotalDeposited() external view returns (uint256) { |
| 1367 | return s_totalDeposited; |
| 1368 | } |
| 1369 | |
| 1370 | function getTotalLoss() external view returns (uint256) { |
| 1371 | return s_totalLoss; |
| 1372 | } |
| 1373 | |
| 1374 | function getTotalRecovered() external view returns (uint256) { |
| 1375 | return s_totalRecovered; |
| 1376 | } |
| 1377 | |
| 1378 | function getProtocolRevenue() external view returns (uint256) { |
| 1379 | return s_protocolRevenue; |
| 1380 | } |
| 1381 | } |
| 1382 |
0.0%
src/interfaces/ICreditPolicy.sol
Lines covered: 0 / 0 (0.0%)
| 1 | // SPDX-License-Identifier: MIT |
| 2 | pragma solidity ^0.8.24; |
| 3 | import {CreditPolicy} from "../CreditPolicy.sol"; |
| 4 | |
| 5 | interface ICreditPolicy { |
| 6 | function createPolicy(uint256 version) external; |
| 7 | |
| 8 | function freezePolicy(uint256 version) external; |
| 9 | |
| 10 | function deActivatePolicy(uint256 version) external; |
| 11 | |
| 12 | function updateEligibility( |
| 13 | uint256 version, |
| 14 | CreditPolicy.EligibilityCriteria calldata data |
| 15 | ) external; |
| 16 | |
| 17 | function updateRatios( |
| 18 | uint256 version, |
| 19 | CreditPolicy.FinancialRatios calldata data |
| 20 | ) external; |
| 21 | |
| 22 | function updateConcentration( |
| 23 | uint256 version, |
| 24 | CreditPolicy.ConcentrationLimits calldata data |
| 25 | ) external; |
| 26 | |
| 27 | function updateAttestation( |
| 28 | uint256 version, |
| 29 | CreditPolicy.AttestationRequirements calldata data |
| 30 | ) external; |
| 31 | |
| 32 | function updateCovenants( |
| 33 | uint256 version, |
| 34 | CreditPolicy.MaintenanceCovenants calldata data |
| 35 | ) external; |
| 36 | |
| 37 | function setLoanTier( |
| 38 | uint256 version, |
| 39 | uint8 tierId, |
| 40 | CreditPolicy.LoanTier calldata tier |
| 41 | ) external; |
| 42 | |
| 43 | function excludeIndustry(uint256 version, bytes32 industry) external; |
| 44 | |
| 45 | function includeIndustry(uint256 version, bytes32 industry) external; |
| 46 | |
| 47 | function setPolicyDocument( |
| 48 | uint256 version, |
| 49 | bytes32 hash, |
| 50 | string calldata uri |
| 51 | ) external; |
| 52 | |
| 53 | function tierExistsInPolicy( |
| 54 | uint256 version, |
| 55 | uint8 tierId |
| 56 | ) external view returns (bool); |
| 57 | |
| 58 | function changePolicyAdmin(address newAdmin) external; |
| 59 | |
| 60 | function isPolicyActive(uint256 version) external view returns (bool); |
| 61 | |
| 62 | function isPolicyFrozen(uint256 version) external view returns (bool); |
| 63 | |
| 64 | function isIndustryExcluded( |
| 65 | uint256 version, |
| 66 | bytes32 industry |
| 67 | ) external view returns (bool); |
| 68 | } |
| 69 |
0.0%
src/interfaces/ITranchePool.sol
Lines covered: 0 / 0 (0.0%)
| 1 | // SPDX-License-Identifier: MIT |
| 2 | pragma solidity ^0.8.24; |
| 3 | import {TranchePool} from "../TranchePool.sol"; |
| 4 | |
| 5 | interface ITranchePool { |
| 6 | // logic functions |
| 7 | |
| 8 | function withdrawEquityTrancheByAmount(uint256 amount) external; |
| 9 | |
| 10 | function withdrawJuniorTrancheByAmount(uint256 amount) external; |
| 11 | |
| 12 | function withdrawSeniorTrancheByAmount(uint256 amount) external; |
| 13 | |
| 14 | function withdrawEquityTranche(uint256 shares) external; |
| 15 | |
| 16 | function withdrawJuniorTranche(uint256 shares) external; |
| 17 | |
| 18 | function withdrawSeniorTranche(uint256 shares) external; |
| 19 | |
| 20 | function onInterestAccrued( |
| 21 | uint256 interestAmount, |
| 22 | uint256 seniorInterest, |
| 23 | uint256 juniorInterest |
| 24 | ) external; |
| 25 | |
| 26 | function onRepayment( |
| 27 | uint256 principalRepaid, |
| 28 | uint256 interestRepaid |
| 29 | ) external; |
| 30 | |
| 31 | function onRecovery(uint256 amount) external; |
| 32 | |
| 33 | function allocateCapital( |
| 34 | uint256 totalDisbursement, |
| 35 | uint256 fees, |
| 36 | address deployer, |
| 37 | address feeManager |
| 38 | ) |
| 39 | external |
| 40 | returns ( |
| 41 | uint256 seniorAmount, |
| 42 | uint256 juniorAmount, |
| 43 | uint256 equityAmount |
| 44 | ); |
| 45 | |
| 46 | function depositEquityTranche(uint256 amount) external; |
| 47 | |
| 48 | function depositJuniorTranche(uint256 amount) external; |
| 49 | |
| 50 | function depositSeniorTranche(uint256 amount) external; |
| 51 | |
| 52 | // updaters |
| 53 | function updateEquityTrancheWhiteList(address user, bool status) external; |
| 54 | |
| 55 | function updateWhitelist(address user, bool status) external; |
| 56 | |
| 57 | // setters |
| 58 | |
| 59 | function onLoss(uint256 principalLoss, uint256 interestAccrued) external; |
| 60 | |
| 61 | function setLoanEngine(address _loanEngine) external; |
| 62 | |
| 63 | function setTargetJuniorAPR(uint256 apr) external; |
| 64 | |
| 65 | function setSeniorAPR(uint256 apr) external; |
| 66 | |
| 67 | function setTrancheCapitalAllocationFactorJunior(uint256 factor) external; |
| 68 | |
| 69 | function setTrancheCapitalAllocationFactorSenior(uint256 factor) external; |
| 70 | |
| 71 | function setMinimumDepositAmountEquityTranche(uint256 amount) external; |
| 72 | |
| 73 | function setMinimumDepositAmountSeniorTranche(uint256 amount) external; |
| 74 | |
| 75 | function setMinimumDepositAmountJuniorTranche(uint256 amount) external; |
| 76 | |
| 77 | // getters |
| 78 | function getEquityTrancheBalance( |
| 79 | address user |
| 80 | ) external view returns (uint256); |
| 81 | |
| 82 | function getJuniorTrancheBalance( |
| 83 | address user |
| 84 | ) external view returns (uint256); |
| 85 | |
| 86 | function getSeniorTrancheBalance( |
| 87 | address user |
| 88 | ) external view returns (uint256); |
| 89 | |
| 90 | function getPoolState() external view returns (TranchePool.PoolState); |
| 91 | |
| 92 | function getSeniorAllocationRatio() external view returns (uint256); |
| 93 | |
| 94 | function getJuniorAllocationRatio() external view returns (uint256); |
| 95 | |
| 96 | function getTotalIdleValue() external view returns (uint256); |
| 97 | } |
| 98 |
0.0%
src/interfaces/IVerifier.sol
Lines covered: 0 / 0 (0.0%)
| 1 | // SPDX-License-Identifier: MIT |
| 2 | pragma solidity ^0.8.24; |
| 3 | |
| 4 | interface IVerifier { |
| 5 | function verify( |
| 6 | bytes calldata _proof, |
| 7 | bytes32[] calldata _publicInputs |
| 8 | ) external returns (bool); |
| 9 | } |
| 10 |
100.0%
test/fuzz/invariant/CreditRailStateFullFuzzTest.t.sol
Lines covered: 76 / 76 (100.0%)
| 1 | // SPDX-License-Identifier: MIT |
| 2 | pragma solidity ^0.8.27; |
| 3 | |
| 4 | import {LoanEngine} from "../../../src/LoanEngine.sol"; |
| 5 | import {TranchePool} from "../../../src/TranchePool.sol"; |
| 6 | import {CreditPolicy} from "../../../src/CreditPolicy.sol"; |
| 7 | import {MockLoanProofVerifier} from "../../mocks/MockLoanProofVerifier.sol"; |
| 8 | import {ERC20Mock} from "@openzeppelin/contracts/mocks/token/ERC20Mock.sol"; |
| 9 | |
| 10 | import {Handler} from "./Handler.t.sol"; |
| 11 | import {Test} from "forge-std/Test.sol"; |
| 12 | import {StdInvariant} from "forge-std/StdInvariant.sol"; |
| 13 | |
| 14 | // we assume protocol revenue is zero as we have equity tranche |
| 15 | contract CreditRailStateFullFuzzTest is StdInvariant, Test { |
| 16 | Handler public handler; |
| 17 | ERC20Mock public usdt; |
| 18 | uint256 public maxOriginationFeeBps = 500; // 5% |
| 19 | TranchePool public tranchePool; |
| 20 | LoanEngine public loanEngine; |
| 21 | CreditPolicy public creditPolicy; |
| 22 | uint256 public USDT = 1e18; |
| 23 | address public deployer = makeAddr("deployer"); |
| 24 | |
| 25 | constructor() { |
| 26 | vm.startPrank(deployer); |
| 27 | usdt = new ERC20Mock(); |
| 28 | tranchePool = new TranchePool(address(usdt)); |
| 29 | tranchePool.setMaxAllocationCapSeniorTranche(5_00_00_000 * USDT); |
| 30 | tranchePool.setMaxAllocationCapJuniorTranche(3_00_00_000 * USDT); |
| 31 | tranchePool.setMaxAllocationCapEquityTranche(2_00_00_000 * USDT); |
| 32 | tranchePool.setMinimumDepositAmountSeniorTranche(10_00_000 * USDT); |
| 33 | tranchePool.setMinimumDepositAmountJuniorTranche(50_00_000 * USDT); |
| 34 | tranchePool.setMinimumDepositAmountEquityTranche(1_00_00_000 * USDT); |
| 35 | tranchePool.setTrancheCapitalAllocationFactorJunior(15); |
| 36 | tranchePool.setTrancheCapitalAllocationFactorSenior(80); |
| 37 | tranchePool.setSeniorAPR(8); |
| 38 | tranchePool.setTargetJuniorAPR(15); |
| 39 | |
| 40 | creditPolicy = new CreditPolicy(); |
| 41 | creditPolicy.setMaxTiers(3); |
| 42 | creditPolicy.createPolicy(1); |
| 43 | |
| 44 | creditPolicy.updateEligibility(1, _createEligibilityCriteria()); |
| 45 | creditPolicy.updateRatios(1, _createFinancialRatios()); |
| 46 | creditPolicy.updateConcentration(1, _createConcentrationLimits()); |
| 47 | creditPolicy.updateAttestation(1, _createAttestationRequirements()); |
| 48 | creditPolicy.updateCovenants(1, _createMaintenanceCovenants()); |
| 49 | creditPolicy.setLoanTier(1, 1, _createMockTier("Tier 1")); |
| 50 | creditPolicy.setPolicyDocument( |
| 51 | 1, |
| 52 | _hashString("document"), |
| 53 | "ipfs://policyDocHash" |
| 54 | ); |
| 55 | creditPolicy.freezePolicy(1); |
| 56 | |
| 57 | MockLoanProofVerifier mockLoanProofVerifier = new MockLoanProofVerifier(); |
| 58 | loanEngine = new LoanEngine( |
| 59 | address(creditPolicy), |
| 60 | address(mockLoanProofVerifier), |
| 61 | maxOriginationFeeBps, |
| 62 | address(tranchePool), |
| 63 | address(usdt) |
| 64 | ); |
| 65 | loanEngine.setMaxOriginationFeeBps(500); |
| 66 | tranchePool.setLoanEngine(address(loanEngine)); |
| 67 | |
| 68 | handler = new Handler(loanEngine, tranchePool, creditPolicy, usdt); |
| 69 | vm.stopPrank(); |
| 70 | bytes4[] memory selectors = new bytes4[](18); |
| 71 | selectors[0] = handler.depositSeniorTranche.selector; |
| 72 | selectors[1] = handler.depositJuniorTranche.selector; |
| 73 | selectors[2] = handler.depositEquityTranche.selector; |
| 74 | selectors[3] = handler.maybeCommitPool.selector; |
| 75 | selectors[4] = handler.createLoan.selector; |
| 76 | selectors[5] = handler.activateLoan.selector; |
| 77 | selectors[6] = handler.repayLoan.selector; |
| 78 | selectors[7] = handler.maybeDeclareDefault.selector; |
| 79 | selectors[8] = handler.maybeWriteOffLoan.selector; |
| 80 | selectors[9] = handler.maybeRecoverLoan.selector; |
| 81 | selectors[10] = handler.warpTime.selector; |
| 82 | selectors[11] = handler.mayClosePool.selector; |
| 83 | selectors[12] = handler.claimSeniorTrancheInterest.selector; |
| 84 | selectors[13] = handler.claimJuniorTrancheInterest.selector; |
| 85 | selectors[14] = handler.claimEquityTrancheInterest.selector; |
| 86 | selectors[15] = handler.withdrawSeniorTranche.selector; |
| 87 | selectors[16] = handler.withdrawJuniorTranche.selector; |
| 88 | selectors[17] = handler.withdrawEquityTranche.selector; |
| 89 | targetSelector( |
| 90 | FuzzSelector({addr: address(handler), selectors: selectors}) |
| 91 | ); |
| 92 | targetContract(address(handler)); |
| 93 | } |
| 94 | |
| 95 | function _createEligibilityCriteria() |
| 96 | internal |
| 97 | pure |
| 98 | returns (CreditPolicy.EligibilityCriteria memory) |
| 99 | { |
| 100 | return |
| 101 | CreditPolicy.EligibilityCriteria({ |
| 102 | minAnnualRevenue: 1_00_00_000, |
| 103 | minEBITDA: 10_00_000, |
| 104 | minTangibleNetWorth: 5_00_00_000, |
| 105 | minBusinessAgeDays: 180, |
| 106 | maxDefaultsLast36Months: 0, |
| 107 | bankruptcyExcluded: true |
| 108 | }); |
| 109 | } |
| 110 | |
| 111 | function _createFinancialRatios() |
| 112 | internal |
| 113 | pure |
| 114 | returns (CreditPolicy.FinancialRatios memory) |
| 115 | { |
| 116 | return |
| 117 | CreditPolicy.FinancialRatios({ |
| 118 | maxTotalDebtToEBITDA: 4e18, |
| 119 | minInterestCoverageRatio: 2e18, |
| 120 | minCurrentRatio: 1e18, |
| 121 | minEBITDAMarginBps: 1500 |
| 122 | }); |
| 123 | } |
| 124 | |
| 125 | function _createConcentrationLimits() |
| 126 | internal |
| 127 | pure |
| 128 | returns (CreditPolicy.ConcentrationLimits memory) |
| 129 | { |
| 130 | return |
| 131 | CreditPolicy.ConcentrationLimits({ |
| 132 | maxSingleBorrowerBps: 1000, |
| 133 | maxIndustryConcentrationBps: 3000 |
| 134 | }); |
| 135 | } |
| 136 | |
| 137 | function _createAttestationRequirements() |
| 138 | internal |
| 139 | pure |
| 140 | returns (CreditPolicy.AttestationRequirements memory) |
| 141 | { |
| 142 | return |
| 143 | CreditPolicy.AttestationRequirements({ |
| 144 | maxAttestationAgeDays: 90, |
| 145 | reAttestationFrequencyDays: 180, |
| 146 | requiresCPAAttestation: true |
| 147 | }); |
| 148 | } |
| 149 | |
| 150 | function _createMaintenanceCovenants() |
| 151 | internal |
| 152 | pure |
| 153 | returns (CreditPolicy.MaintenanceCovenants memory) |
| 154 | { |
| 155 | return |
| 156 | CreditPolicy.MaintenanceCovenants({ |
| 157 | maxLeverageRatio: 4e18, |
| 158 | minCoverageRatio: 2e18, |
| 159 | minLiquidityAmount: 1_00_00_000, |
| 160 | allowsDividends: false, |
| 161 | reportingFrequencyDays: 90 |
| 162 | }); |
| 163 | } |
| 164 | |
| 165 | function _createMockTier( |
| 166 | string memory name |
| 167 | ) internal pure returns (CreditPolicy.LoanTier memory) { |
| 168 | return |
| 169 | CreditPolicy.LoanTier({ |
| 170 | name: name, |
| 171 | minRevenue: 1_00_00_000, |
| 172 | maxRevenue: 5_00_00_000, |
| 173 | minEBITDA: 10_00_000, |
| 174 | maxDebtToEBITDA: 3e18, |
| 175 | maxLoanToEBITDA: 2e18, |
| 176 | interestRateBps: 800, |
| 177 | originationFeeBps: 100, |
| 178 | termDays: 365, |
| 179 | active: true |
| 180 | }); |
| 181 | } |
| 182 | |
| 183 | function _hashString(string memory str) internal pure returns (bytes32) { |
| 184 | return keccak256(bytes(str)); |
| 185 | } |
| 186 | |
| 187 | function invariant__totalIdleAndDeployedValueMatchesAccounting() |
| 188 | public |
| 189 | view |
| 190 | { |
| 191 | assertEq( |
| 192 | tranchePool.getTotalIdleValue() + |
| 193 | tranchePool.getTotalDeployedValue(), |
| 194 | tranchePool.getTotalDeposited() - |
| 195 | tranchePool.getTotalLoss() + |
| 196 | tranchePool.getTotalRecovered(), |
| 197 | "Total idle and deployed value does not match handler accounting" |
| 198 | ); |
| 199 | } |
| 200 | |
| 201 | function invariant__OutStandingPrincipalMatchesDeployed() public view { |
| 202 | assertEq( |
| 203 | handler.outStandingPrincipal(), |
| 204 | tranchePool.getTotalDeployedValue(), |
| 205 | "Outstanding principal does not match deployed minus recovered and loss" |
| 206 | ); |
| 207 | } |
| 208 | } |
| 209 |
11.0%
test/fuzz/invariant/Handler.t.sol
Lines covered: 43 / 379 (11.0%)
| 1 | // SPDX-License-Identifier: MIT |
| 2 | pragma solidity ^0.8.27; |
| 3 | |
| 4 | import {Test, console} from "forge-std/Test.sol"; |
| 5 | import {LoanEngine} from "../../../src/LoanEngine.sol"; |
| 6 | import {TranchePool} from "../../../src/TranchePool.sol"; |
| 7 | import {ERC20Mock} from "@openzeppelin/contracts/mocks/token/ERC20Mock.sol"; |
| 8 | import {CreditPolicy} from "../../../src/CreditPolicy.sol"; |
| 9 | import {MockLoanProofVerifier} from "../../mocks/MockLoanProofVerifier.sol"; |
| 10 | |
| 11 | contract Handler is Test { |
| 12 | LoanEngine loanEngine; |
| 13 | TranchePool tranchePool; |
| 14 | ERC20Mock usdt; |
| 15 | CreditPolicy creditPolicy; |
| 16 | address deployer = makeAddr("deployer"); |
| 17 | uint256 public USDT = 1e18; |
| 18 | bool allowFullDeployment = true; |
| 19 | // 100m$ is the expected principal from lp's |
| 20 | uint256 public expectedPrincipal = 10_00_00_000 * USDT; |
| 21 | uint256 public minimumLoanPrincipal = 10_00_000 * USDT; |
| 22 | uint256 public maximumLoanPrincipal = 2_00_00_000 * USDT; |
| 23 | uint256 public minimumOriginationFeeBps = 50; // 0.5% |
| 24 | uint256 public minimumTermDays = 180; |
| 25 | uint256 public maximumTermDays = 480; |
| 26 | address[] public seniorUsers; |
| 27 | address[] public juniorUsers; |
| 28 | address[] public equityUsers; |
| 29 | uint256 public activePolicyVersion = 1; |
| 30 | uint256 public defaultCounter; |
| 31 | uint256 public writeOffCounter; |
| 32 | uint256 public recoveryCounter; |
| 33 | |
| 34 | uint256 public seniorTrancheIdleValue; |
| 35 | uint256 public seniorTrancheDeployedValue; |
| 36 | |
| 37 | uint256 public juniorTrancheIdleValue; |
| 38 | uint256 public juniorTrancheDeployedValue; |
| 39 | |
| 40 | uint256 public equityTrancheIdleValue; |
| 41 | uint256 public equityTrancheDeployedValue; |
| 42 | |
| 43 | uint256 public seniorTrancheTotalShares; |
| 44 | mapping(address => uint256) public seniorTrancheShares; |
| 45 | mapping(address => uint256) public seniorTrancheDeposits; |
| 46 | mapping(address => uint256) public seniorUserIndex; |
| 47 | |
| 48 | uint256 public juniorTrancheTotalShares; |
| 49 | mapping(address => uint256) public juniorTrancheShares; |
| 50 | mapping(address => uint256) public juniorTrancheDeposits; |
| 51 | mapping(address => uint256) public juniorUserIndex; |
| 52 | |
| 53 | uint256 public equityTrancheTotalShares; |
| 54 | mapping(address => uint256) public equityTrancheShares; |
| 55 | mapping(address => uint256) public equityTrancheDeposits; |
| 56 | mapping(address => uint256) public equityUserIndex; |
| 57 | |
| 58 | address[] public loanBorrowers; |
| 59 | |
| 60 | address public recevingEntity = makeAddr("recevingEntity"); |
| 61 | address public feeManager = makeAddr("feeManager"); |
| 62 | |
| 63 | uint256 public totalIdleValue; |
| 64 | uint256 public totalDeployedValue; |
| 65 | uint256 public totalDeposited; |
| 66 | uint256 public totalLoss; |
| 67 | uint256 public totalRecovered; |
| 68 | |
| 69 | uint256 public outStandingPrincipal; |
| 70 | |
| 71 | constructor( |
| 72 | LoanEngine _loanEngine, |
| 73 | TranchePool _tranchePool, |
| 74 | CreditPolicy _creditPolicy, |
| 75 | ERC20Mock _usdt |
| 76 | ) { |
| 77 | loanEngine = _loanEngine; |
| 78 | tranchePool = _tranchePool; |
| 79 | usdt = _usdt; |
| 80 | creditPolicy = _creditPolicy; |
| 81 | |
| 82 | vm.startPrank(deployer); |
| 83 | loanEngine.setWhitelistedFeeManager(feeManager, true); |
| 84 | loanEngine.setWhitelistedOffRampingEntity(recevingEntity, true); |
| 85 | loanEngine.setWhitelistedRepaymentAgent(recevingEntity, true); |
| 86 | loanEngine.setWhitelistedRecoveryAgent(recevingEntity, true); |
| 87 | |
| 88 | for (uint160 i = 1; i < 100; i++) { |
| 89 | seniorUsers.push(address(i)); |
| 90 | if (i % 2 == 0) { |
| 91 | ERC20Mock(usdt).mint(address(i), 1_00_00_00000 * 1e18); |
| 92 | tranchePool.updateWhitelist(address(i), true); |
| 93 | } else if (i % 3 == 0) { |
| 94 | ERC20Mock(usdt).mint(address(i), 50_0000_0000 * 1e18); |
| 95 | tranchePool.updateWhitelist(address(i), true); |
| 96 | } else { |
| 97 | ERC20Mock(usdt).mint(address(i), 10_000_0000000 * 1e18); |
| 98 | tranchePool.updateWhitelist(address(i), true); |
| 99 | } |
| 100 | } |
| 101 | for (uint160 i = 1; i < 10; i++) { |
| 102 | juniorUsers.push(address(i)); |
| 103 | if (i % 2 == 0) { |
| 104 | ERC20Mock(usdt).mint(address(i), 500000_00_000 * 1e18); |
| 105 | tranchePool.updateWhitelist(address(i), true); |
| 106 | } else { |
| 107 | tranchePool.updateWhitelist(address(i), true); |
| 108 | ERC20Mock(usdt).mint(address(i), 10_000000_000 * 1e18); |
| 109 | } |
| 110 | } |
| 111 | for (uint160 i = 1; i < 5; i++) { |
| 112 | equityUsers.push(address(i)); |
| 113 | ERC20Mock(usdt).mint(address(i), 50_0000_0000 * 1e18); |
| 114 | tranchePool.updateEquityTrancheWhiteList(address(i), true); |
| 115 | } |
| 116 | |
| 117 | for (uint160 i = 200; i < 220; i++) { |
| 118 | loanBorrowers.push(address(i)); |
| 119 | } |
| 120 | ERC20Mock(usdt).mint(address(recevingEntity), 50_0000_0000 * 1e18); |
| 121 | |
| 122 | vm.stopPrank(); |
| 123 | } |
| 124 | |
| 125 | function depositSeniorTranche(uint256 userIndex, uint256 amount) public { |
| 126 | if (tranchePool.getPoolState() != TranchePool.PoolState.OPEN) { |
| 127 | return; |
| 128 | } |
| 129 | address user = seniorUsers[userIndex % seniorUsers.length]; |
| 130 | amount = bound( |
| 131 | amount, |
| 132 | tranchePool.getSeniorTrancheMinimumDepositAmount(), |
| 133 | tranchePool.getSeniorTrancheMaxDepositCap() |
| 134 | ); |
| 135 | if ( |
| 136 | amount + seniorTrancheIdleValue + seniorTrancheDeployedValue > |
| 137 | tranchePool.getSeniorTrancheMaxDepositCap() |
| 138 | ) { |
| 139 | amount = |
| 140 | tranchePool.getSeniorTrancheMaxDepositCap() - |
| 141 | seniorTrancheIdleValue - |
| 142 | seniorTrancheDeployedValue; |
| 143 | if (amount < tranchePool.getSeniorTrancheMinimumDepositAmount()) { |
| 144 | return; |
| 145 | } |
| 146 | } |
| 147 | if (amount == 0) return; |
| 148 | vm.startPrank(user); |
| 149 | ERC20Mock(usdt).approve(address(tranchePool), amount); |
| 150 | tranchePool.depositSeniorTranche(amount); |
| 151 | seniorTrancheIdleValue += amount; |
| 152 | seniorTrancheDeposits[user] += amount; |
| 153 | seniorTrancheShares[user] += amount; |
| 154 | seniorTrancheTotalShares += amount; |
| 155 | totalIdleValue += amount; |
| 156 | seniorUserIndex[user] = tranchePool.getSeniorInterestIndex(); |
| 157 | vm.stopPrank(); |
| 158 | } |
| 159 | |
| 160 | function depositJuniorTranche(uint256 userIndex, uint256 amount) public { |
| 161 | if (tranchePool.getPoolState() != TranchePool.PoolState.OPEN) { |
| 162 | return; |
| 163 | } |
| 164 | address user = juniorUsers[userIndex % juniorUsers.length]; |
| 165 | amount = bound( |
| 166 | amount, |
| 167 | tranchePool.getJuniorTrancheMinimumDepositAmount(), |
| 168 | tranchePool.getJuniorTrancheMaxDepositCap() |
| 169 | ); |
| 170 | if ( |
| 171 | amount + juniorTrancheIdleValue + juniorTrancheDeployedValue > |
| 172 | tranchePool.getJuniorTrancheMaxDepositCap() |
| 173 | ) { |
| 174 | amount = |
| 175 | tranchePool.getJuniorTrancheMaxDepositCap() - |
| 176 | juniorTrancheIdleValue - |
| 177 | juniorTrancheDeployedValue; |
| 178 | if (amount < tranchePool.getJuniorTrancheMinimumDepositAmount()) { |
| 179 | return; |
| 180 | } |
| 181 | } |
| 182 | if (amount == 0) return; |
| 183 | vm.startPrank(user); |
| 184 | ERC20Mock(usdt).approve(address(tranchePool), amount); |
| 185 | tranchePool.depositJuniorTranche(amount); |
| 186 | juniorTrancheIdleValue += amount; |
| 187 | juniorTrancheDeposits[user] += amount; |
| 188 | juniorTrancheShares[user] += amount; |
| 189 | juniorTrancheTotalShares += amount; |
| 190 | totalIdleValue += amount; |
| 191 | juniorUserIndex[user] = tranchePool.getJuniorInterestIndex(); |
| 192 | vm.stopPrank(); |
| 193 | } |
| 194 | |
| 195 | function depositEquityTranche(uint256 userIndex, uint256 amount) public { |
| 196 | if (tranchePool.getPoolState() != TranchePool.PoolState.OPEN) { |
| 197 | return; |
| 198 | } |
| 199 | address user = equityUsers[userIndex % equityUsers.length]; |
| 200 | amount = bound( |
| 201 | amount, |
| 202 | tranchePool.getEquityTrancheMinimumDepositAmount(), |
| 203 | tranchePool.getEquityTrancheMaxDepositCap() |
| 204 | ); |
| 205 | if ( |
| 206 | amount + |
| 207 | tranchePool.getEquityTrancheIdleValue() + |
| 208 | tranchePool.getEquityTrancheDeployedValue() > |
| 209 | tranchePool.getEquityTrancheMaxDepositCap() |
| 210 | ) { |
| 211 | amount = |
| 212 | tranchePool.getEquityTrancheMaxDepositCap() - |
| 213 | tranchePool.getEquityTrancheIdleValue() - |
| 214 | tranchePool.getEquityTrancheDeployedValue(); |
| 215 | if (amount < tranchePool.getEquityTrancheMinimumDepositAmount()) { |
| 216 | return; |
| 217 | } |
| 218 | } |
| 219 | if (amount == 0) return; |
| 220 | vm.startPrank(user); |
| 221 | ERC20Mock(usdt).approve(address(tranchePool), amount); |
| 222 | tranchePool.depositEquityTranche(amount); |
| 223 | |
| 224 | // Ghost State Updates |
| 225 | equityTrancheIdleValue += amount; |
| 226 | equityTrancheDeposits[user] += amount; |
| 227 | equityTrancheShares[user] += amount; |
| 228 | equityTrancheTotalShares += amount; |
| 229 | totalIdleValue += amount; |
| 230 | equityUserIndex[user] = tranchePool.getEquityInterestIndex(); |
| 231 | |
| 232 | vm.stopPrank(); |
| 233 | } |
| 234 | |
| 235 | function maybeCommitPool() public { |
| 236 | if ( |
| 237 | tranchePool.getPoolState() == TranchePool.PoolState.OPEN && |
| 238 | tranchePool.getTotalIdleValue() > 0 |
| 239 | ) { |
| 240 | vm.prank(deployer); |
| 241 | tranchePool.setPoolState(TranchePool.PoolState.COMMITED); |
| 242 | totalDeposited = tranchePool.getTotalIdleValue(); |
| 243 | } |
| 244 | } |
| 245 | |
| 246 | function createLoan( |
| 247 | uint256 principalIssued, |
| 248 | uint256 originationFeeBps, |
| 249 | uint256 termDays, |
| 250 | uint256 userIndex |
| 251 | ) public { |
| 252 | if ( |
| 253 | tranchePool.getPoolState() != TranchePool.PoolState.COMMITED && |
| 254 | tranchePool.getPoolState() != TranchePool.PoolState.DEPLOYED |
| 255 | ) { |
| 256 | return; |
| 257 | } |
| 258 | // 10% is reserved(no full deployment) |
| 259 | uint256 minPrincipal = minimumLoanPrincipal; |
| 260 | |
| 261 | if (allowFullDeployment) { |
| 262 | if (tranchePool.getTotalIdleValue() < minPrincipal) { |
| 263 | minPrincipal = tranchePool.getTotalIdleValue(); |
| 264 | } |
| 265 | } else { |
| 266 | if (tranchePool.getTotalIdleValue() < minPrincipal * 10) { |
| 267 | return; |
| 268 | } |
| 269 | } |
| 270 | |
| 271 | if (tranchePool.getTotalIdleValue() < minimumLoanPrincipal) { |
| 272 | return; |
| 273 | } |
| 274 | |
| 275 | principalIssued = bound( |
| 276 | principalIssued, |
| 277 | minimumLoanPrincipal, |
| 278 | _min(maximumLoanPrincipal, tranchePool.getTotalIdleValue()) |
| 279 | ); |
| 280 | |
| 281 | if (principalIssued > tranchePool.getTotalIdleValue() / 10) { |
| 282 | principalIssued = tranchePool.getTotalIdleValue() / 10; |
| 283 | } |
| 284 | |
| 285 | originationFeeBps = bound( |
| 286 | originationFeeBps, |
| 287 | minimumOriginationFeeBps, |
| 288 | loanEngine.getMaxOriginationFeeBps() |
| 289 | ); |
| 290 | termDays = bound(termDays, minimumTermDays, maximumTermDays); |
| 291 | if (!creditPolicy.isPolicyFrozen(activePolicyVersion)) { |
| 292 | return; |
| 293 | } |
| 294 | |
| 295 | bytes32 borrowerCommitment = keccak256( |
| 296 | abi.encodePacked( |
| 297 | loanBorrowers[userIndex % loanBorrowers.length], |
| 298 | userIndex |
| 299 | ) |
| 300 | ); |
| 301 | |
| 302 | // Get nextLoanId BEFORE vm.prank to avoid consuming the prank |
| 303 | uint256 nextLoanId = loanEngine.getNextLoanId(); |
| 304 | bytes memory proofData = abi.encodePacked( |
| 305 | nextLoanId, |
| 306 | userIndex, |
| 307 | principalIssued, |
| 308 | originationFeeBps, |
| 309 | termDays |
| 310 | ); |
| 311 | |
| 312 | vm.prank(deployer); |
| 313 | loanEngine.createLoan( |
| 314 | borrowerCommitment, |
| 315 | keccak256(abi.encode(nextLoanId,userIndex,borrowerCommitment, block.timestamp)), // nullifierHash |
| 316 | activePolicyVersion, |
| 317 | 1, |
| 318 | principalIssued, |
| 319 | 500, |
| 320 | originationFeeBps, |
| 321 | termDays, |
| 322 | bytes32(0), // industry |
| 323 | proofData, |
| 324 | new bytes32[](0) |
| 325 | ); |
| 326 | } |
| 327 | |
| 328 | function activateLoan(uint256 loanId) public { |
| 329 | if (loanEngine.getNextLoanId() != 1) { |
| 330 | loanId = bound(loanId, 1, loanEngine.getNextLoanId() - 1); |
| 331 | } |
| 332 | |
| 333 | if ( |
| 334 | loanEngine.getLoanDetails(loanId).state != |
| 335 | LoanEngine.LoanState.CREATED |
| 336 | ) { |
| 337 | return; |
| 338 | } |
| 339 | if ( |
| 340 | tranchePool.getPoolState() != TranchePool.PoolState.COMMITED && |
| 341 | tranchePool.getPoolState() != TranchePool.PoolState.DEPLOYED |
| 342 | ) { |
| 343 | return; |
| 344 | } |
| 345 | |
| 346 | if ( |
| 347 | loanEngine.getLoanDetails(loanId).principalIssued > |
| 348 | tranchePool.getTotalIdleValue() |
| 349 | ) { |
| 350 | return; |
| 351 | } |
| 352 | |
| 353 | vm.prank(deployer); |
| 354 | loanEngine.activateLoan(loanId, recevingEntity, feeManager); |
| 355 | totalDeployedValue += loanEngine.getLoanDetails(loanId).principalIssued; |
| 356 | totalIdleValue -= loanEngine.getLoanDetails(loanId).principalIssued; |
| 357 | outStandingPrincipal += loanEngine |
| 358 | .getLoanDetails(loanId) |
| 359 | .principalIssued; |
| 360 | } |
| 361 | |
| 362 | function repayLoan( |
| 363 | uint256 loanId, |
| 364 | uint256 principalAmount, |
| 365 | uint256 interestAmount |
| 366 | ) public { |
| 367 | if (loanEngine.getNextLoanId() == 1) { |
| 368 | return; |
| 369 | } |
| 370 | loanId = bound(loanId, 1, loanEngine.getNextLoanId() - 1); |
| 371 | LoanEngine.Loan memory loanDetails = loanEngine.getLoanDetails(loanId); |
| 372 | if (loanDetails.state != LoanEngine.LoanState.ACTIVE) { |
| 373 | return; |
| 374 | } |
| 375 | console.log("here"); |
| 376 | principalAmount = bound( |
| 377 | principalAmount, |
| 378 | 0, |
| 379 | loanDetails.principalOutstanding |
| 380 | ); |
| 381 | |
| 382 | uint256 pendingInterest = _accrueInterest(loanId); |
| 383 | uint256 totalInterestDue = loanDetails.interestAccrued + |
| 384 | pendingInterest; |
| 385 | |
| 386 | interestAmount = bound(interestAmount, 0, totalInterestDue); |
| 387 | |
| 388 | if (principalAmount == 0 && interestAmount == 0) { |
| 389 | return; |
| 390 | } |
| 391 | |
| 392 | if ( |
| 393 | principalAmount > 0 && interestAmount == 0 && totalInterestDue > 0 |
| 394 | ) { |
| 395 | return; |
| 396 | } |
| 397 | |
| 398 | uint256 totalRepayAmount = principalAmount + interestAmount; |
| 399 | uint256 interestAccrued = loanDetails.interestAccrued + |
| 400 | _accrueInterest(loanId); |
| 401 | uint256 actualInterestPaid = _min(totalRepayAmount, interestAccrued); |
| 402 | uint256 actualPrincipalPaid = _min( |
| 403 | totalRepayAmount - actualInterestPaid, |
| 404 | loanDetails.principalOutstanding |
| 405 | ); |
| 406 | |
| 407 | vm.prank(recevingEntity); |
| 408 | ERC20Mock(usdt).approve(address(loanEngine), totalRepayAmount); |
| 409 | vm.prank(deployer); |
| 410 | loanEngine.repayLoan( |
| 411 | loanId, |
| 412 | principalAmount, |
| 413 | interestAmount, |
| 414 | recevingEntity |
| 415 | ); |
| 416 | totalDeployedValue -= actualPrincipalPaid; |
| 417 | totalIdleValue += actualPrincipalPaid; |
| 418 | outStandingPrincipal -= actualPrincipalPaid; |
| 419 | } |
| 420 | |
| 421 | function warpTime(uint256 daysToWarp) public { |
| 422 | daysToWarp = bound(daysToWarp, 1, 365); |
| 423 | vm.warp(block.timestamp + (daysToWarp * 1 days)); |
| 424 | } |
| 425 | |
| 426 | function maybeDeclareDefault(uint256 loanId, bytes32 reasonHash) public { |
| 427 | if (loanEngine.getNextLoanId() == 1) { |
| 428 | return; |
| 429 | } |
| 430 | defaultCounter++; |
| 431 | |
| 432 | // 🔒 90% of the time → return |
| 433 | if (defaultCounter % 10 != 0) { |
| 434 | return; |
| 435 | } |
| 436 | |
| 437 | loanId = bound(loanId, 1, loanEngine.getNextLoanId() - 1); |
| 438 | |
| 439 | LoanEngine.Loan memory loan = loanEngine.getLoanDetails(loanId); |
| 440 | |
| 441 | if (loan.state != LoanEngine.LoanState.ACTIVE) { |
| 442 | return; |
| 443 | } |
| 444 | |
| 445 | vm.prank(deployer); |
| 446 | loanEngine.declareDefault(loanId, reasonHash); |
| 447 | } |
| 448 | |
| 449 | function maybeWriteOffLoan(uint256 loanId) public { |
| 450 | if (loanEngine.getNextLoanId() == 1) { |
| 451 | return; |
| 452 | } |
| 453 | |
| 454 | writeOffCounter++; |
| 455 | |
| 456 | // ~1 in 20 handler calls |
| 457 | if (writeOffCounter % 20 != 0) { |
| 458 | return; |
| 459 | } |
| 460 | |
| 461 | loanId = bound(loanId, 1, loanEngine.getNextLoanId() - 1); |
| 462 | |
| 463 | if ( |
| 464 | loanEngine.getLoanDetails(loanId).state != |
| 465 | LoanEngine.LoanState.DEFAULTED |
| 466 | ) { |
| 467 | return; |
| 468 | } |
| 469 | |
| 470 | // Read principal before writeoff as it zeroes it out |
| 471 | uint256 principalOutstanding = loanEngine |
| 472 | .getLoanDetails(loanId) |
| 473 | .principalOutstanding; |
| 474 | |
| 475 | vm.prank(deployer); |
| 476 | loanEngine.writeOffLoan(loanId); |
| 477 | totalDeployedValue -= principalOutstanding; |
| 478 | outStandingPrincipal -= principalOutstanding; |
| 479 | totalLoss += principalOutstanding; |
| 480 | } |
| 481 | |
| 482 | function maybeRecoverLoan( |
| 483 | uint256 loanId, |
| 484 | uint256 amount, |
| 485 | uint256 agentIndex |
| 486 | ) public { |
| 487 | if (loanEngine.getNextLoanId() == 1) { |
| 488 | return; |
| 489 | } |
| 490 | recoveryCounter++; |
| 491 | |
| 492 | // ~1 in 30 handler calls |
| 493 | if (recoveryCounter % 30 != 0) { |
| 494 | return; |
| 495 | } |
| 496 | |
| 497 | loanId = bound(loanId, 1, loanEngine.getNextLoanId() - 1); |
| 498 | |
| 499 | LoanEngine.Loan memory loan = loanEngine.getLoanDetails(loanId); |
| 500 | if (loan.state != LoanEngine.LoanState.WRITTEN_OFF) { |
| 501 | return; |
| 502 | } |
| 503 | |
| 504 | address recoveryAgent = seniorUsers[agentIndex % seniorUsers.length]; |
| 505 | |
| 506 | amount = bound(amount, 1, loan.principalIssued); |
| 507 | |
| 508 | vm.startPrank(recoveryAgent); |
| 509 | ERC20Mock(usdt).mint(recoveryAgent, amount); |
| 510 | ERC20Mock(usdt).approve(address(loanEngine), amount); |
| 511 | vm.stopPrank(); |
| 512 | |
| 513 | vm.prank(deployer); |
| 514 | loanEngine.recoverLoan(loanId, amount, recoveryAgent); |
| 515 | totalIdleValue += amount; |
| 516 | totalRecovered += amount; |
| 517 | } |
| 518 | |
| 519 | // accounting functions for invariants |
| 520 | |
| 521 | function mayClosePool() public { |
| 522 | if(tranchePool.getTotalDeployedValue() > 0 || tranchePool.getPoolState() != TranchePool.PoolState.DEPLOYED){ |
| 523 | return; |
| 524 | } |
| 525 | vm.prank(deployer); |
| 526 | tranchePool.setPoolState(TranchePool.PoolState.CLOSED); |
| 527 | } |
| 528 | |
| 529 | function claimSeniorTrancheInterest(uint256 userIndex) public { |
| 530 | userIndex = bound(userIndex, 0, seniorUsers.length - 1); |
| 531 | if (tranchePool.poolState() != TranchePool.PoolState.CLOSED) { |
| 532 | return; |
| 533 | } |
| 534 | address user = seniorUsers[userIndex]; |
| 535 | if (tranchePool.getSeniorTrancheShares(user) == 0) { |
| 536 | return; |
| 537 | } |
| 538 | if ( |
| 539 | tranchePool.getSeniorInterestIndex() - |
| 540 | tranchePool.getSeniorUserIndex(user) <= |
| 541 | 0 |
| 542 | ) { |
| 543 | return; |
| 544 | } |
| 545 | vm.prank(user); |
| 546 | tranchePool.claimSeniorInterest(); |
| 547 | } |
| 548 | |
| 549 | function claimJuniorTrancheInterest(uint256 userIndex) public { |
| 550 | userIndex = bound(userIndex, 0, juniorUsers.length - 1); |
| 551 | if (tranchePool.poolState() != TranchePool.PoolState.CLOSED) { |
| 552 | return; |
| 553 | } |
| 554 | address user = juniorUsers[userIndex]; |
| 555 | if (tranchePool.getJuniorTrancheShares(user) == 0) { |
| 556 | return; |
| 557 | } |
| 558 | if ( |
| 559 | tranchePool.getJuniorInterestIndex() - |
| 560 | tranchePool.getJuniorUserIndex(user) <= |
| 561 | 0 |
| 562 | ) { |
| 563 | return; |
| 564 | } |
| 565 | vm.prank(user); |
| 566 | tranchePool.claimJuniorInterest(); |
| 567 | } |
| 568 | |
| 569 | function claimEquityTrancheInterest(uint256 userIndex) public { |
| 570 | userIndex = bound(userIndex, 0, equityUsers.length - 1); |
| 571 | if (tranchePool.poolState() != TranchePool.PoolState.CLOSED) { |
| 572 | return; |
| 573 | } |
| 574 | address user = equityUsers[userIndex]; |
| 575 | if (tranchePool.getEquityTrancheShares(user) == 0) { |
| 576 | return; |
| 577 | } |
| 578 | if ( |
| 579 | tranchePool.getEquityInterestIndex() - |
| 580 | tranchePool.getEquityUserIndex(user) == |
| 581 | 0 |
| 582 | ) { |
| 583 | return; |
| 584 | } |
| 585 | vm.prank(user); |
| 586 | tranchePool.claimEquityInterest(); |
| 587 | } |
| 588 | |
| 589 | function withdrawSeniorTranche(uint256 userIndex, uint256 amount) public { |
| 590 | if(tranchePool.getPoolState() != TranchePool.PoolState.CLOSED){ |
| 591 | return; |
| 592 | } |
| 593 | userIndex = bound(userIndex, 0, seniorUsers.length - 1); |
| 594 | address user = seniorUsers[userIndex]; |
| 595 | amount = bound(amount, 0, tranchePool.getSeniorTrancheShares(user)); |
| 596 | |
| 597 | if (amount == 0) return; |
| 598 | |
| 599 | // Ensure interest is claimed before withdraw (as per new contract guard) |
| 600 | if (tranchePool.getSeniorInterestIndex() != tranchePool.getSeniorUserIndex(user)) { |
| 601 | claimSeniorTrancheInterest(userIndex); |
| 602 | } |
| 603 | |
| 604 | // Calculate expected asset withdrawal based on HANDLER's view of state |
| 605 | // Replicating contract logic: (shares * idle) / totalShares |
| 606 | uint256 currentIdle = seniorTrancheIdleValue; |
| 607 | uint256 currentShares = seniorTrancheTotalShares; |
| 608 | |
| 609 | uint256 amountToWithdraw = (amount * currentIdle) / currentShares; |
| 610 | |
| 611 | vm.prank(user); |
| 612 | tranchePool.withdrawSeniorTranche(amount); |
| 613 | |
| 614 | // Update Ghost State |
| 615 | if (seniorTrancheDeposits[user] >= amountToWithdraw) { |
| 616 | seniorTrancheDeposits[user] -= amountToWithdraw; |
| 617 | } else { |
| 618 | seniorTrancheDeposits[user] = 0; |
| 619 | } |
| 620 | |
| 621 | seniorTrancheShares[user] -= amount; |
| 622 | seniorTrancheTotalShares -= amount; |
| 623 | |
| 624 | seniorTrancheIdleValue -= amountToWithdraw; |
| 625 | totalIdleValue -= amountToWithdraw; |
| 626 | } |
| 627 | |
| 628 | function withdrawJuniorTranche(uint256 userIndex, uint256 amount) public { |
| 629 | if(tranchePool.getPoolState() != TranchePool.PoolState.CLOSED){ |
| 630 | return; |
| 631 | } |
| 632 | userIndex = bound(userIndex, 0, juniorUsers.length - 1); |
| 633 | address user = juniorUsers[userIndex]; |
| 634 | amount = bound(amount, 0, tranchePool.getJuniorTrancheShares(user)); |
| 635 | |
| 636 | if (amount == 0) return; |
| 637 | |
| 638 | if (tranchePool.getJuniorInterestIndex() != tranchePool.getJuniorUserIndex(user)) { |
| 639 | claimJuniorTrancheInterest(userIndex); |
| 640 | } |
| 641 | |
| 642 | uint256 currentIdle = juniorTrancheIdleValue; |
| 643 | uint256 currentShares = juniorTrancheTotalShares; |
| 644 | |
| 645 | uint256 amountToWithdraw = (amount * currentIdle) / currentShares; |
| 646 | |
| 647 | vm.prank(user); |
| 648 | tranchePool.withdrawJuniorTranche(amount); |
| 649 | |
| 650 | if (juniorTrancheDeposits[user] >= amountToWithdraw) { |
| 651 | juniorTrancheDeposits[user] -= amountToWithdraw; |
| 652 | } else { |
| 653 | juniorTrancheDeposits[user] = 0; |
| 654 | } |
| 655 | |
| 656 | juniorTrancheShares[user] -= amount; |
| 657 | juniorTrancheTotalShares -= amount; |
| 658 | juniorTrancheIdleValue -= amountToWithdraw; |
| 659 | totalIdleValue -= amountToWithdraw; |
| 660 | } |
| 661 | |
| 662 | function withdrawEquityTranche(uint256 userIndex, uint256 amount) public { |
| 663 | if(tranchePool.getPoolState() != TranchePool.PoolState.CLOSED){ |
| 664 | return; |
| 665 | } |
| 666 | userIndex = bound(userIndex, 0, equityUsers.length - 1); |
| 667 | address user = equityUsers[userIndex]; |
| 668 | amount = bound(amount, 0, tranchePool.getEquityTrancheShares(user)); |
| 669 | if (amount == 0) return; |
| 670 | |
| 671 | if (tranchePool.getEquityInterestIndex() != tranchePool.getEquityUserIndex(user)) { |
| 672 | claimEquityTrancheInterest(userIndex); |
| 673 | } |
| 674 | |
| 675 | uint256 currentIdle = equityTrancheIdleValue; |
| 676 | uint256 currentShares = equityTrancheTotalShares; |
| 677 | |
| 678 | // Safety check to avoid div by zero if logic is flawed elsewhere |
| 679 | if (currentShares == 0) return; |
| 680 | |
| 681 | uint256 amountToWithdraw = (amount * currentIdle) / currentShares; |
| 682 | |
| 683 | vm.prank(user); |
| 684 | tranchePool.withdrawEquityTranche(amount); |
| 685 | |
| 686 | if (equityTrancheDeposits[user] >= amountToWithdraw) { |
| 687 | equityTrancheDeposits[user] -= amountToWithdraw; |
| 688 | } else { |
| 689 | equityTrancheDeposits[user] = 0; |
| 690 | } |
| 691 | |
| 692 | equityTrancheShares[user] -= amount; |
| 693 | equityTrancheTotalShares -= amount; |
| 694 | equityTrancheIdleValue -= amountToWithdraw; |
| 695 | totalIdleValue -= amountToWithdraw; |
| 696 | } |
| 697 | |
| 698 | function totalExpectedSeniorDeposits() public view returns (uint256) { |
| 699 | uint256 total; |
| 700 | for (uint256 i = 0; i < seniorUsers.length; i++) { |
| 701 | total += seniorTrancheDeposits[seniorUsers[i]]; |
| 702 | } |
| 703 | return total; |
| 704 | } |
| 705 | |
| 706 | function totalExpectedJuniorDeposits() public view returns (uint256) { |
| 707 | uint256 total; |
| 708 | for (uint256 i = 0; i < juniorUsers.length; i++) { |
| 709 | total += juniorTrancheDeposits[juniorUsers[i]]; |
| 710 | } |
| 711 | return total; |
| 712 | } |
| 713 | |
| 714 | function totalExpectedSeniorShares() public view returns (uint256) { |
| 715 | uint256 total; |
| 716 | for (uint256 i = 0; i < seniorUsers.length; i++) { |
| 717 | total += seniorTrancheShares[seniorUsers[i]]; |
| 718 | } |
| 719 | return total; |
| 720 | } |
| 721 | |
| 722 | function totalExpectedJuniorShares() public view returns (uint256) { |
| 723 | uint256 total; |
| 724 | for (uint256 i = 0; i < juniorUsers.length; i++) { |
| 725 | total += juniorTrancheShares[juniorUsers[i]]; |
| 726 | } |
| 727 | return total; |
| 728 | } |
| 729 | |
| 730 | function getSeniorTrancheIdleValue() public view returns (uint256) { |
| 731 | return seniorTrancheIdleValue; |
| 732 | } |
| 733 | |
| 734 | function getJuniorTrancheIdleValue() public view returns (uint256) { |
| 735 | return juniorTrancheIdleValue; |
| 736 | } |
| 737 | |
| 738 | function getSeniorTrancheTotalShares() public view returns (uint256) { |
| 739 | return seniorTrancheTotalShares; |
| 740 | } |
| 741 | |
| 742 | function getJuniorTrancheTotalShares() public view returns (uint256) { |
| 743 | return juniorTrancheTotalShares; |
| 744 | } |
| 745 | |
| 746 | function _min(uint256 a, uint256 b) internal pure returns (uint256) { |
| 747 | return a < b ? a : b; |
| 748 | } |
| 749 | |
| 750 | function _accrueInterest(uint256 loanId) internal view returns (uint256) { |
| 751 | // Implementation goes here |
| 752 | loanId = bound(loanId, 1, loanEngine.getNextLoanId() - 1); |
| 753 | LoanEngine.Loan memory loan = loanEngine.getLoanDetails(loanId); |
| 754 | |
| 755 | uint256 timeElapsed = block.timestamp - loan.lastAccrualTimestamp; |
| 756 | if (loan.principalOutstanding == 0) { |
| 757 | return 0; |
| 758 | } |
| 759 | |
| 760 | uint256 interest = (loan.principalOutstanding * |
| 761 | loan.aprBps * |
| 762 | timeElapsed) / (365 days * 10_000); |
| 763 | |
| 764 | return interest; |
| 765 | } |
| 766 | } |
| 767 |
50.0%
test/mocks/MockLoanProofVerifier.sol
Lines covered: 1 / 2 (50.0%)
| 1 | // SPDX-License-Identifier: MIT |
| 2 | pragma solidity ^0.8.24; |
| 3 | |
| 4 | contract MockLoanProofVerifier { |
| 5 | function verify( |
| 6 | bytes calldata proof, |
| 7 | bytes32[] calldata publicInputs |
| 8 | ) external pure returns (bool) { |
| 9 | return true; |
| 10 | } |
| 11 | } |
| 12 |